## Complete List of #$ActorSlots

E-Mail Comments to: doc@cyc.com
Last Update: 10/30/1998 16:16:32
Copyright© 1996, 1997, 1998 Cycorp. All rights reserved.

Return to Table of Contents
Search for Constants by Name (In all files, not just this one.)

#### #$actors : <#$Event> <#$SomethingExisting>

> 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.
> Cyclist Notes: In (#$actors EVENT ACTOR), unlike with many other predicates, ACTOR need not be a #$subAbstrac that is #$cotemporal with EVENT due to some special machinery in code.
> isa: #$ActorSlot
> genlPreds: #$temporallyIntersects
> some more specialized predicates: #$trajectory-Partial #$target #$eventOccursAt #$instrument-Generic #$nonDeliberateActors #$preActors #$postActors #$trajectory-Complete #$pathway-Complete #$transporter #$instrument-Container #$stuffUsed #$programUsed #$deviceUsed #$conveyor-Generic

#### #$preActors : <#$Event> <#$SomethingExisting>

> The predicate #$preActors is used to indicate a participant that pre-exists a particular event. (#$preActors EVENT OBJECT) means that OBJECT exists before EVENT begins. It makes no commitment about OBJECT's condition during or after EVENT. #$preActors is a very general #$ActorSlot, subsuming #$doneBy, #$objectActedOn, #$objectMoving, and many others.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$actors #$startsAfterStartingOf
> some more specialized predicates: #$recipientOfService #$constrainingObject #$providerOfMotiveForce #$governedByAgreement #$actorPartsInvolved #$fromLocation #$socialParticipants #$objectActedOn #$spectators #$infectingOrganism #$unchangedActors #$parentActors #$communicationTarget #$transferredThing #$commitsForFutureUses

#### #$postActors : <#$Event> <#$SomethingExisting>

> The predicate #$postActors is used to indicate a participant that continues to exist after a particular event. (#$postActors EVENT OBJECT) means that OBJECT exists after EVENT ends. It makes no commitment about OBJECT's condition before or during EVENT. #$postActors is a very general element of #$ActorSlot; it subsumes #$outputsCreated, #$doneBy, and many others.
> isa: #$ActorSlot
> genlPreds: #$actors
> some more specialized predicates: #$recipientOfService #$objectTakenCareOf #$objectOfStateChange #$constrainingObject #$unchangedActors #$transferredThing #$toLocation #$outputs #$toPossessor #$inputsCommitted #$exchangers #$payer #$birthChild #$birthParent #$transporter

#### #$unchangedActors : <#$Event> <#$PartiallyTangible>

> (#$unchangedActors EV OBJ) means that the object OBJ remains virtually unchanged by its participation in the event EV. This means that OBJ does not appreciably move, nor does it undergo some internal change in its properties, nor is it created or destroyed in the course of EV.
> isa: #$AsymmetricBinaryPredicate #$ActorUseTypeSlot
> genlPreds: #$preActors #$postActors
> some more specialized predicates: #$catalyst #$programUsed

#### #$deliberateActors : <#$Event> <#$Agent>

> (#$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.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$preActors
> some more specialized predicates: #$exhibitors #$crewMember #$assistingAgent #$performedBy #$directingAgent #$mediators #$driverActor #$successfulForAgents #$perpetrator #$buyingPerformer #$sellingPerformer #$failureForAgents #$providerOfService #$performedByPart #$majorUndertakingsOf

#### #$nonDeliberateActors : <#$Event> <#$SomethingExisting>

> (#$nonDeliberateActors ACT ACTR) means that ACTR has a #$Role in the #$Event ACT but is not acting deliberately. Examples: (1) President #$JohnKennedy was a #$nonDeliberateActors in his assassination; (2) a person is a #$nonDeliberateActors in his/her own autonomic bodily functioning (e.g., heart beating, digesting); (3) Mount #$Vesuvius-Volcano was a #$nonDeliberateActors in the event of its eruption that destroyed Pompeii. #$nonDeliberateActors is a negative specification of the role an actor has in an event; the role of particular #$nonDeliberateActors might be further specified positively, e.g., with #$bodilyActedOn or #$bodilyDoer.
> Cyclist Notes: Why do we want this when we can state (#$not (#$deliberateActors Foo Bar))? Because (#$not (#$deliberateActors ACT ACTOR)) may either mean that ACTOR was not an actor in ACT, or it may mean that ACTOR was in the #$actors role in ACT but did not act in a deliberate fashion. Thus #$nonDeliberateActors allows greater specificity.
> isa: #$ActorSlot
> genlPreds: #$actors
> some more specialized predicates: #$outputsCreated #$actorPartsAffected #$trajectoryPassesThrough #$destination-RoundTrip #$origin-RoundTrip #$actorPartsInvolved #$bodilyDoer #$offspringActors #$iboCreated #$pathway-Partial #$infectionHost #$birthParent #$pathway-Complete

#### #$pathway-Complete : <#$Movement-TranslationEvent> <#$Path-Spatial>

> The predicate #$pathway-Complete is used to indicate that the whole #$Trajectory (i.e., the #$trajectory-Complete) travelled by a moving object in a particular event follows a certain #$Path-Spatial along its whole length, and that the movement goes along the whole of the #$Path-Spatial from end to end. (#$pathway-Complete MOVE PATH) means that the #$Path-Spatial PATH contains the entire #$Trajectory along which an #$objectMoving travels in the #$Movement-TranslationEvent MOVE. (The #$Traversal determined by #$trajectory-Complete occupies the whole length of PATH.) There can be at most one #$pathway-Complete if MOVE is an element of #$Translation-SingleTrajectory. If MOVE is an element of #$Translation-MultiTrajectory, then there can be two or more #$pathway-Completes; i.e., at least two distinct values of PATH such that (#$pathway-Complete MOVE PATH) is true. PATH may be a marked or unmarked #$Path-Spatial. By definition, any #$pathway-Complete of a #$Movement-TranslationEvent connects the starting and stopping points (#$fromLocation, #$toLocation) of the whole movement event. (See also #$pathConnects.) Use #$trajectoryPassesThrough to state that an object passes through a particular location on the #$Trajectory. Note: Compare #$pathway-Complete with #$pathway-Partial; the former refers to a #$Path-Spatial containing the entire route of a particular #$trajectory-Complete. A sub-region (shorter segment) of a #$pathway-Complete is NOT itself considered a #$pathway-Complete of the same movement event; i.e., if (#$pathway-Complete MOVE PATH) is true, and we cut PATH up into ten pieces PATH1, ..., PATH10, then it will generally not be true that (#$pathway-Complete MOVE PATH8), but it will be true that (#$pathway-Partial MOVE PATH8).
> Cyclist Notes: (i) The first part of the comment should be rewritten, for what is there now (5/15/98) hardly makes sense if MOVE is a #$Translation-MultiTrajectory. (ii) Strictly speaking, when MOVE is a #$Translation-SingleTrajectory, whose #$fromLocation is FROM and #$toLocation is TO, (#$pathway-Complete MOVE PATH) means the same thing as (#$traverses-Complete MOVE (#$TraversalFn (#$TheList FROM PATH TO))).
> isa: #$ActorSlot
> genlPreds: #$pathway-Partial #$eventOccursAt

#### #$pathway-Partial : <#$Translation-SingleTrajectory> <#$Path-Spatial>

> (pathway-Partial MOVE PATH) means that MOVE is a #$Movement-TranslationEvent with a #$Trajectory (see #$trajectory-Complete) which has a sub-trajectory in common with some #$subPaths of the #$Path-Generic PATH. For example, if a certain trip to Dallas from Austin is via highway I-35, that does not mean either that the whole journey is along I-35 (it also may be along driveways and side streets), or that it is along all of I-35 (which would take you from the Mexican border all the way to the Canadian border). A part of the journey is along a part of I-35. This is in contrast to #$pathway-Complete, which relates a movement's entire #$trajectory-Complete to an entire #$Path-Generic from end to end.
> isa: #$ActorSlot
> genlPreds: #$trajectoryPassesThrough #$temporallyIntersects
> some more specialized predicates: #$pathway-Complete

#### #$trajectoryPassesThrough : <#$Translation-SingleTrajectory> <#$SpatialThing-Localized>

> (#$trajectoryPassesThrough MOVE LOC) means that the #$trajectory-Complete of the #$Translation-SingleTrajectory MOVE passes through LOC, which is an instance of #$SpatialThing-Localized, and thus can be a location, a portal, a river, a path, the equator, etc. More formally, the #$objectMoving which undergoes MOVE from the #$fromLocation to the #$toLocation passes through LOC. Here `passes through LOC' means that the #$objectMoving OBJ both arrives in and leaves LOC. Thus, LOC can not be a super region of any #$fromLocation nor any #$toLocations of MOVE. Otherwise it would be possible to state (#$trajectoryPassesThrough TripToTheStore01 TheUniverse). On the other hand, LOC can be a sub region of some #$toLocation or some #$fromLocation.
> See #$NoteAboutTrajectoriesTraversalsAndPaths for (further) documentation.
> Cyclist Notes: Arg2 should be fixed to those that are 'stationary' relative to the frame of reference. Although this is hard to say in CycL, at least we should have it in the comment. If later we need to use this predicate with arg2 to be something not stationary, we must check whether all rules connecting trajectories and traversals still hold.
> isa: #$ActorSlot
> genlPreds: #$nonDeliberateActors
> some more specialized predicates: #$pathway-Partial #$pathway-Complete

#### #$eventOccursAt : <#$Event> <#$SpatialThing-Localized>

> The predicate #$eventOccursAt relates a particular event to the instance of #$PartiallyTangible in which it occurs. (#$eventOccursAt EVENT PT) means that the spatial extent of EVENT is within PT. For example, (#$eventOccursAt #$LomaPrietaEarthquake #$SanFranciscoBayArea).
> isa: #$ActorSlot
> genlPreds: #$temporallyIntersects #$actors
> some more specialized predicates: #$trajectory-Complete #$pathway-Complete

#### #$eventOccursNear : <#$Event> <#$PartiallyTangible>

> The predicate #$eventOccursNear is used to give an approximate location for an event. (#$eventOccursNear EVENT LOC) means that EVENT occurs at a place #$near LOC. #$eventOccursNear is useful when the more exact #$eventOccursAt is unknown, hard to specify, or not worth reifying. For example, #$eventOccursNear is useful for describing the location of events in scenarios such as `Bob was cycling by the dam', `We played checkers near the TV', and `He is standing by the horse's hind legs'. See #$cyclistNotes for ideas on how to formalize this.
> Cyclist Notes: It would be reasonable to make the `near' of this predicate sensitive to the situations in which it is used, perhaps by making the distance from the event to the #$eventOccursNear location a function of the dimensions of some or all of the other #$actors involved in the event (e.g., #$pathway-Complete (or -Partial), #$doneBy, #$objectActedOn, #$objectOfStateChange). But this remains to be done.
> isa: #$ActorSlot

#### #$toLocation : <#$Translocation> <#$PartiallyTangible>

> The predicate #$toLocation is used to indicate the ending point of a particular movement. (#$toLocation MOVE LOC) means that LOC is where the #$objectMoving in MOVE (a #$Movement-TranslationEvent) is found when the event MOVE ends; the final location of the #$objectMoving in that event is LOC. The #$objectMoving may or may not be #$Stationary at LOC. If MOVE is a single-pathway translation (see #$Translation-SingleTrajectory), then every #$objectMoving in it is found at LOC when MOVE ends. If MOVE has multiple movers and multiple pathways (see #$Translation-MultiTrajectory), then at least some of the #$objectMoving(s) can be found at LOC at the end of MOVE. If MOVE is a fluid flow (see #$Translation-Flow), then at least some portion of the fluid #$objectMoving can be found at location LOC at the end of MOVE. See also #$pathway-Complete, #$pathConnects.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$postActors #$to-Generic (#$MeaningInSystemFn #$SENSUS-Information1997)
> some more specialized predicates: #$origin-RoundTrip

#### #$fromLocation : <#$Translocation> <#$PartiallyTangible>

> The predicate #$fromLocation is used to indicate the starting point of a particular movement. (#$fromLocation MOVE LOC) means that LOC is where the #$objectMoving in the #$Movement-TranslationEvent MOVE is found at the beginning of MOVE and is where it begins this motion. The #$objectMoving may or may not be #$Stationary at LOC. If MOVE is a single-pathway translation (see #$Translation-SingleTrajectory), then every #$objectMoving is found at LOC when MOVE starts. If MOVE has multiple movers and multiple pathways (see #$Translation-MultiTrajectory), then at least some of the #$objectMoving(s) can be found at LOC at the start of MOVE. If MOVE is a flow (including rivers flowing, winds blowing, tornado, typhoon, clouds moving and even air filling your lungs when you take breath, see #$Translation-Flow), then at least some portion of the fluid #$objectMoving can be found at LOC at the start of MOVE. See also #$pathway-Complete, #$pathConnects.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$preActors #$from-Generic (#$MeaningInSystemFn #$SENSUS-Information1997)
> some more specialized predicates: #$emitter #$origin-RoundTrip

#### #$emitter : <#$Emission> <#$PartiallyTangible>

> The Cyc predicate #$emitter is used to identify the source of an emission. (#$emitter EMIT OBJ) means that OBJ provides the force involved in making the #$objectEmitted move from OBJ to someplace outside of OBJ. See also #$providerOfMotiveForce, #$fromLocation.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$providerOfMotiveForce #$fromLocation #$doneBy

#### #$target : <#$GeneralizedTransfer> <#$PartiallyTangible>

> (#$target TRANS PLACE) means that the #$performedBy (or #$directingAgent) of the event TRANS intends that the #$transferredThing end up at PLACE.
> isa: #$ActorSlot
> genlPreds: #$actors

#### #$origin-RoundTrip : <#$Translation-RoundTrip> <#$PartiallyTangible>

> (#$origin-RoundTrip TRIP PLACE) means that the #$Translation-RoundTrip event TRIP leaves from and returns to the location PLACE. PLACE is both the #$fromLocation and #$toLocation of the entire TRIP, considered as a whole. For example, some commuters to Manhattan leave and return each day to #$Connecticut-State, which is their #$origin-RoundTrip. See also #$destination-RoundTrip.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$fromLocation #$toLocation #$nonDeliberateActors

#### #$destination-RoundTrip : <#$Translation-RoundTrip> <#$PartiallyTangible>

> (#$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.
> isa: #$ActorSlot
> genlPreds: #$nonDeliberateActors

#### #$fromPossessor : <#$LosingUserRights> <#$Agent>

> This predicate identifies an #$Agent who loses some right to use an object. (#$fromPossessor LOSS AGENT) means that AGENT enjoys some #$UserRightsAttribute over the #$objectOfPossessionTransfer at the start of the #$LosingUserRights event LOSS, but no longer has that particular #$UserRightsAttribute after the LOSS ends.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$preActors #$from-Generic
> some more specialized predicates: #$payer

#### #$toPossessor : <#$GainingUserRights> <#$Agent>

> This predicate identifies an #$Agent who gains some right to use an object. (#$toPossessor GAIN AGENT) means that after the event GAIN (a #$GainingUserRights), AGENT enjoys some #$UserRightsAttribute over the #$objectOfPossessionTransfer which that agent did not have at the start of GAIN.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot #$ProcessPredicate
> genlPreds: #$postActors #$to-Generic

#### #$exchangers : <#$ExchangeOfUserRights> <#$Agent>

> The predicate #$exchangers is used to identify the (typically, two) #$Agents involved in an instance of #$ExchangeOfUserRights. In such an event, each of the #$exchangers gives up possession of one thing and gains possession of another which was previously possessed by the other agent. (#$exchangers EXCH AGENT) means that AGENT is one of the parties having such a dual role in the #$ExchangeOfUserRights EXCH. Every instance of #$ExchangeOfUserRights has two sub-events which are instances of #$TransferringPossession (e.g., a dollar bill goes in one direction and some french fries and a few coins go in the other direction.) Each of the #$exchangers is both a #$toPossessor (in one of the two #$TransferringPossession sub-events of EXCH) and a #$fromPossessor (in the other sub-event).
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$socialParticipants #$performedBy #$postActors #$preActors
> some more specialized predicates: #$buyer #$seller

#### #$buyer : <#$MonetaryExchangeOfUserRights> <#$Agent>

> 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.
> isa: #$AgentiveRole #$AsymmetricBinaryPredicate
> genlPreds: #$exchangers #$prospectiveBuyer

#### #$seller : <#$MonetaryExchangeOfUserRights> <#$Agent>

> The predicate #$seller relates an agent to a sales event. (#$seller EVENT AGENT) means that the #$Agent AGENT sells something in the #$CommercialActivity EVENT.
> isa: #$AgentiveRole #$AsymmetricBinaryPredicate
> genlPreds: #$exchangers #$prospectiveSeller #$providerOfService

#### #$senderOfInfo : <#$InformationTransferEvent> <#$Agent>

> The predicate #$senderOfInfo is used to indicate the sending agent in a particular transfer of information. (#$senderOfInfo TRANSFER SENDER) means that SENDER is an agent who is the source of information transferred in the #$InformationTransferEvent TRANSFER. At the time of TRANSFER (and typically for some period beforehand), SENDER conceives of the information transferred in TRANSFER. It's not the case that SENDER necessarily #$knows the `information' or has it among his/her #$beliefs, because TRANSFER could involve lying; e.g., #$GeorgeWashington's telling his father, `I didn't chop down the cherry tree'. SENDER normally performs TRANSFER intentionally, but some transfers may be unintentional; e.g., when one repeats some gossip unwittingly within earshot of the person being discussed, the transfer to the overhearer is unintentional. See also #$infoTransferred.
> isa: #$AgentiveRole #$AsymmetricBinaryPredicate
> genlPreds: #$informationOrigin #$from-Generic #$doneBy

#### #$recipientOfInfo : <#$InformationTransferEvent> <#$Agent>

> The predicate #$recipientOfInfo is used to indicate who receives information in a particular communication event. (#$recipientOfInfo TRANSFER RECIP) means that the information transferred in the #$InformationTransferEvent TRANSFER is received by the #$Agent RECIP. After TRANSFER, RECIP understands or conceives of the information transferred in TRANSFER; Cyc does NOT conclude that s/he #$knows the information or counts it among his/her #$beliefs, because RECIP might not believe it. In receiving the information transferred, RECIP may be acting intentionally or unintentionally. See also #$infoTransferred.
> Cyclist Notes: We need to document how to decide between #$recipientOfInfo and #$informationDestination better (#$BillJ 12 Marh 97)
> isa: #$AgentiveRole #$AsymmetricBinaryPredicate
> genlPreds: #$informationDestination

#### #$communicationTarget : <#$CommunicationAct-Single> <#$PartiallyTangible>

> 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.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$preActors

#### #$transferredThing : <#$GeneralizedTransfer> <#$SomethingExisting>

> The Cyc predicate #$transferredThing is used to identify the object whose external relationships change in some event considered generically as a `transfer'. (#$transferredThing TRANSFER OBJ) means that OBJ is being moved, transferred, exchanged, etc., in the #$GeneralizedTransfer event TRANSFER. In general, and if possible, it is preferable to use a more specialized instance of #$ActorSlot than #$transferredThing (e.g., #$objectMoving for physical transfer of an object; #$objectOfPossessionTransfer for an object that changes possession but not necessarily location; and so on).
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$preActors #$postActors
> some more specialized predicates: #$objectOfPossessionTransfer #$objectMoving #$objectPaidFor #$objectTendered #$primaryObjectMoving #$objectEmitted #$transporter #$transportees #$vehicle #$crewMember #$passengers #$driverActor

#### #$objectOfPossessionTransfer : <#$ChangeInUserRights> <#$SomethingExisting>

> The predicate #$objectOfPossessionTransfer identifies the object which `changes hands' in a particular event wherein some user's rights to it are changed. (#$objectOfPossessionTransfer EVENT OBJECT) means that in EVENT, all or some rights to use OBJECT are transferred from one agent (the #$fromPossessor) to another (the #$toPossessor). EVENT is an element of #$ChangeInUserRights (q.v.), for example, a buying, renting, lending, repossessing, etc.
> isa: #$AsymmetricBinaryPredicate #$ActorUseTypeSlot
> genlPreds: #$transferredThing
> some more specialized predicates: #$objectPaidFor #$objectTendered

#### #$objectPaidFor : <#$MonetaryExchangeOfUserRights> <#$SomethingExisting>

> (#$objectPaidFor EVENT OBJECT) means that in the #$MonetaryExchangeOfUserRights EVENT, the right to possess OBJECT is transferred from one #$Agent to another. OBJ is not the #$objectTendered but the goods that are bought or rented.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$objectOfPossessionTransfer

#### #$objectTendered : <#$MoneyTransfer> <#$TenderObject>

> This predicate indicates the financial instrument which is used in a particular transfer of money. (#$objectTendered TRANS OBJECT) means that the #$TenderObject OBJECT is used to transfer funds in the #$MoneyTransfer event TRANS. See also #$TenderObject. Note: OBJECT is distinct from the quantity of #$Money transferred (see #$moneyTransferred) although of course OBJECT has some value --- is `worth' a certain amount, generally calculated from the numbers printed or stamped or engraved on the #$TenderObject OBJECT --- which in turn is an element of #$Money.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$objectOfPossessionTransfer

#### #$objectMoving : <#$MovementEvent> <#$PartiallyTangible>

> The predicate #$objectMoving is used to refer to an object which is moving in a particular #$MovementEvent. (#$objectMoving MOVE OBJECT) means that OBJECT is in motion at some point during the #$MovementEvent MOVE and is either the #$primaryObjectMoving in MOVE or #$subEvents of MOVE. OBJECT need not move from the #$fromLocation to the #$toLocation. If it does, and moves along the trajectory of MOVE, then it is a #$primaryObjectMoving, part of a #$primaryObjectMoving, or contained in a #$primaryObjectMoving. A part of or object contained by a #$primaryObjectMoving may or may not also be #$primaryObjectMoving.
> Cyclist Notes: Around 1 Sept '98 #$BillJ disputed the meaning of this constant and requested feedback from the KE review board. If you are planning on using this constant in KE, with a meaning different from the current definition (e.g. to represent the primary object moving in an event, instead of using the more specific #$primaryObjectMoving) please drop #$Foxvog an email. Please read the comment on both #$objectMoving and #$primaryObjectMoving.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$transferredThing #$temporallyIntersects
> some more specialized predicates: #$primaryObjectMoving #$objectEmitted #$transporter #$transportees #$vehicle #$crewMember #$passengers #$driverActor

#### #$objectEmitted : <#$EmittingAnObject> <#$PartiallyTangible>

> This predicate is used in connection with particular instances of #$EmittingAnObject, to identify the object which `comes out' during the event. (#$objectEmitted EMIT OBJ) means that OBJ is emitted from the #$emitter during the emission event EMIT. The #$objectEmitted is also an #$objectMoving in EMIT. For example, in a particular human #$BirthEvent, some particular #$HumanInfant is an #$objectEmitted.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$objectMoving

#### #$transporter : <#$TransportationEvent> <#$SolidTangibleThing>

> (#$transporter MOVE OBJ) means that OBJ enables or facilitates the conveyance of the #$transportees in the #$TransportationEvent MOVE. OBJ is an #$objectMoving in MOVE that moves along with the #$transportees. OBJ will generally hold, support, contain, pull, or push the #$transportees throughout the MOVE #$Event. OBJ may or may not be the #$providerOfMotiveForce in the event MOVE. If OBJ stays with each #$primaryObjectMoving from the #$fromLocation to the #$toLocation, moving along the same trajectory, then it is also a #$primaryObjectMoving.
> `` If OBJ facilitates the motion of the #$primaryObjectMoving but does not itself engage in translational motion it is merely the conveyor of the action, and the role #$conveyor-Stationary should be asserted. If it is unclear whether the conveyor is stationary or not, the role #$conveyor-Generic is used. Specializations of the role #$transporter should be used when possible: although automobiles are #$transporters in many events, they should normally have the more specific role designation of #$vehicle because they are also #$SelfPoweredDevices. When a car is being towed by a towtruck, the car is just a #$transporter of any of its contents while the towtruck is the #$vehicle of that event. An additional role designation for some #$transporters -- those which are #$PhysicalDevices -- is #$deviceUsed; e.g., the use of crutches in hobbling or ice skates in skating. See the #$comment on #$TransportationEvent. Note that an organism may be a #$transportees in a #$Bicycle riding or #$Skating event as well as being the #$providerOfMotiveForce in such cases.
> See #$DecidingWhichInstrumentPredicateToUse for (further) documentation.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot #$IrreflexiveBinaryPredicate
> genlPreds: #$objectMoving #$instrument-Generic #$constrainingObject #$conveyor-Generic
> some more specialized predicates: #$vehicle

#### #$vehicle : <#<(#$TransportViaFn #$TransportationDevice-Vehicle)>> <#$TransportationDevice-Vehicle>

> (#$vehicle EVENT VEHICLE) means that VEHICLE is a #$TransportationDevice-Vehicle which is both the #$providerOfMotiveForce and the #$transporter in EVENT. If an object is a #$TransportationDevice-Vehicle and plays the role of #$transporter in some moving event, then it generally will play the role of #$vehicle in that event. Examples: a car plays the role of #$vehicle in driving. Note, however, that a bicycle does not play the role of #$vehicle in bike riding since it is not a provider of motive force. A borderline non-example is someone sitting in their car while it's being pulled by a towtruck; their car is not playing the role of #$vehicle in that event.
> See #$DecidingWhichInstrumentPredicateToUse for (further) documentation.
> isa: #$AntiTransitiveBinaryPredicate #$AsymmetricBinaryPredicate #$ActorSlot #$IrreflexiveBinaryPredicate
> genlPreds: #$deviceUsed #$transporter #$providerOfMotiveForce

#### #$transportees : <#$Conveying-Generic> <#$PartiallyTangible>

> The predicate #$transportees relates a translational motion event to the object(s) transported by another one of the #$actors in that event. (#$transportees MOVE OBJ) means that some #$transporter facilitates the conveyance of OBJ in MOVE. For example, in a dumptruck driving event, the dirt in the back of the truck is a #$transportees. Any humans in the truck cab (or truck bed) during the trip are also #$transportees; however, a more precise role designation for humans riding in the truck would be either #$passengers or (for the driver) #$driverActor. Borderline positive example #$transportees include the clothes worn by a person walking, or a horseshoe worn by a horse walking. A negative exemplar of a #$transportees is the ear of the person walking. This is because #$transporters do not transport their parts when they move. Note also that parts of #$transportees are not necessarily #$transportees themselves. See also the #$comments on #$TransportationEvent and #$transporter.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$objectMoving #$objectActedOn #$primaryObjectMoving
> some more specialized predicates: #$crewMember #$passengers #$driverActor

#### #$driverActor : <#$TransportationEvent> <#$Person>

> (#$driverActor DRIVE DRIVER) means that DRIVER controls (see #$ControllingATransporter) the #$transporter in DRIVE. DRIVER steers the wheel, graps the tiller, controls the throttle, the reins, the brakes etc of the #$transporter, e.g. a boat, train, windsurfer, mule, plane, horse and carriage, spaceship, sled, etc.. DRIVER is not a #$passengers in DRIVE. Because #$transporter and #$transportees are disjoint and #$driverActor has #$transportees as a #$genlPreds, DRIVER is distinct from the value on #$transporter. Thus a person walking while carrying a watermelon would not be a #$driverActor in their own walking. DRIVER is usually in #$SittingPosture during DRIVE. For any given instant of DRIVE there is exactly one DRIVER. Until we have more extensive vocabulary, #$transportees is the most specific we can be about events in which multiple drivers share driving responsibility throughout the event or if there is a pilot/co-pilot combination.
> Cyclist Notes: One of the more picayune and unimportant rename suggestions, but would be a little nicer if this were called simply called driver.
> isa: #$AgentiveRole #$AsymmetricBinaryPredicate
> genlPreds: #$transportees #$performedBy #$crewMember

#### #$passengers : <#$TransportationEvent> <#$Person>

> (#$passengers MOVE PAS) means that PAS is a human #$transportees in MOVE who is not a #$driverActor for any #$subEvents of Move. Any PAS is not a #$driverActor for any #$subEvents of MOVE. PAS is likely to be sitting (see #$SittingPosture) during the MOVE.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$transportees

#### #$parentActors : <#$BiologicalProductionEvent> <#$BiologicalLivingObject>

> (#$parentActors EV P) means that organism P is one of the parents in the #$BiologicalReproductionEvent EV.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$preActors
> some more specialized predicates: #$maleParentActor #$femaleParentActor

#### #$maleParentActor : <#$SexualReproductionEvent> <#$Organism-Whole>

> (#$maleParentActor ?EVENT ?ORGANISM) means that ?ORGANISM is the male parent in the #$SexualReproductionEvent ?EVENT.
> isa: #$AntiTransitiveBinaryPredicate #$AsymmetricBinaryPredicate #$ActorSlot #$FunctionalSlot
> genlPreds: #$parentActors

#### #$femaleParentActor : <#$SexualReproductionEvent> <#$BiologicalLivingObject>

> (#$femaleParentActor ?EVENT ?ORGANISM) means that ?ORGANISM is the female parent in the #$SexualReproductionEvent ?EVENT.
> isa: #$AntiTransitiveBinaryPredicate #$AsymmetricBinaryPredicate #$ActorSlot #$FunctionalSlot
> genlPreds: #$parentActors

#### #$birthParent : <#$BirthEvent> <#$Animal>

> (#$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.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$bodilyDoer #$objectOfStateChange

#### #$birthChild : <#$BirthEvent> <#$Animal>

> (#$birthChild BIRTH ANIM) means that ANIM is the #$Animal that is born in the #$BirthEvent BIRTH.
> isa: #$AntiTransitiveBinaryPredicate #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$bodilyActedOn #$objectOfStateChange

#### #$infectionHost : <#$Infection> <#$Organism-Whole>

> This predicate relates a particular case of #$Infection to the organism it is infecting. (#$infectionHost INF ORG) means that INF is an #$Infection in which the host organism is ORG.
> isa: #$AntiTransitiveBinaryPredicate #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$bodilyDoer

#### #$infectingOrganism : <#$Infection> <#$Organism-Whole>

> This predicate relates a particular instance of #$Infection to an organism which causes that infection. (#$infectingOrganism INFECT ORG) means that the organism ORG is one of the causes of the infection INFECT. For example, if INFECT is a case of #$StrepThroat, then ORG is an instance of #$Streptococcus. I.e., (#$forAll ?x (#$forAll ?y (#$implies (#$and (#$isa ?x #$StrepThroat) (#$infectingOrganism ?x ?y)) (#$isa ?y #$Streptococcus))))
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$preActors

#### #$actorPartsInvolved : <#$Event> <#$OrganismPart>

> (#$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.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$preActors #$nonDeliberateActors

#### #$consumesPortion : <#$Event> <#$PartiallyTangible>

> (#$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.
> isa: #$AsymmetricBinaryPredicate #$ActorUseTypeSlot
> genlPreds: #$objectActedOn

#### #$commitsForFutureUses : <#$Event> <#$SomethingExisting>

> (#$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.
> Cyclist Notes: An Arg 3 type collection should probably added. (#$commitsForFutureUses Painting01 Paper02 PaintingAPicture) means that whatever role that Paper02 played in Painting01 can not be played by Paper02 in any subsequent element of PainingAPicture....There is no way to formalize this predicate as arity2.
> isa: #$AsymmetricBinaryPredicate #$ActorUseTypeSlot
> genlPreds: #$preActors
> some more specialized predicates: #$inputsCommitted

#### #$inputs : <#$CreationOrDestructionEvent> <#$SomethingExisting>

> The predicate #$inputs relates a particular event to things which are `inputs', i.e., materials used in that event and somehow altered by it. (#$inputs EVENT OBJECT) means that OBJECT is an input to the #$CreationOrDestructionEvent EVENT. During and due to the event, OBJECT is either destroyed or incorporated into a new entity. For example, the pigments used to paint the Mona Lisa were #$inputs to Leonardo's painting process; however, his brushes were not #$inputs, even though they were changed a little by it. In general, in instances of #$Manufacturing, materials or objects are inputs if they find their way into the product manufactured, or if they are destroyed -- such as the coke used in manufacturing steel -- as part of that manufacturing process. Note: One should use the specialized predicates #$inputsDestroyed or #$inputsCommitted whenever they are appropriate, rather than the more general predicate #$inputs.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$preActors #$startsAfterStartingOf #$objectActedOn
> some more specialized predicates: #$inputsDestroyed #$inputsCommitted

#### #$inputsDestroyed : <#$DestructionEvent> <#$SomethingExisting>

> The predicate #$inputsDestroyed is used to relate a particular event to the items which are destroyed by it. (#$inputsDestroyed EVENT OBJECT) means that OBJECT exists before EVENT, is affected by EVENT, and due to that involvement, ends its existence as an #$Entity sometime during EVENT. OBJECT may or may not be a #$deliberateActors in EVENT.
> isa: #$AntiTransitiveBinaryPredicate #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$inputs #$endsAfterEndingOf

#### #$inputsCommitted : <#$CreationEvent> <#$SomethingExisting>

> The predicate #$inputsCommitted is used when some #$inputs to a particular event is incorporated into some #$outputs of that event, but remains recognizable rather than being destroyed. (#$inputsCommitted EVENT OBJECT) means that OBJECT exists before EVENT and continues to exist afterwards, and as a result of EVENT, OBJECT becomes incorporated into something created during EVENT. For example, bricks that are used to build a house continue to exist as bricks once the house has been built. (See also #$outputsCreated.) Note: there is a grey area between #$inputsCommitted and #$inputsDestroyed; the less possible it is to take apart the relevant #$outputs of EVENT and get OBJECT back as an independent thing, the more likely it is that the relationship between EVENT and OBJECT should be #$inputsDestroyed, rather than #$inputsCommitted.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$postActors #$inputs #$commitsForFutureUses

#### #$outputs : <#$CreationOrDestructionEvent> <#$SomethingExisting>

> The predicate #$outputs is used to relate a particular event to any of the outputs from that event. (#$outputs EVENT OBJECT) means that OBJECT is an output from the #$CreationOrDestructionEvent EVENT; i.e., OBJECT is either created as a result of EVENT, or it is something left after another thing was destroyed in EVENT. For example, silicon chips are #$outputsCreated in a chip manufacturing process, while scrap metal is #$outputsRemaining after cars are put through a crusher. Note that those two types of cases should be distinguished by using (respectively) the specialized predicates #$outputsCreated or #$outputsRemaining whenever they are appropriate, rather than only the more general predicate #$outputs.
> isa: #$ActorSlot
> genlPreds: #$postActors #$actors
> some more specialized predicates: #$byProducts #$products #$outputsCreated #$outputsRemaining #$wasteProducts #$offspringActors #$iboCreated

#### #$outputsRemaining : <#$DestructionEvent> <#$SomethingExisting>

> The predicate #$outputsRemaining is used to identify leftovers which survive from the #$inputs to a particular event. (#$outputsRemaining EVENT OBJECT) means that OBJECT persists after EVENT, and that it existed before EVENT as an identifiable part of one of the things destroyed during EVENT (see #$inputsDestroyed). Examples: (1) when a sheet of plywood is sawn through in a cutting event, the original board is destroyed and the #$outputsRemaining are the two smaller plywood pieces; (2) after a #$FiltrationProcess, the #$suspendedPart and the #$suspendingFluid are the #$outputsRemaining from the original mixture which has been destroyed.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$preActors #$outputs

#### #$outputsCreated : <#$CreationEvent> <#$SomethingExisting>

> The predicate #$outputsCreated is used to identify items created by a particular event. (#$outputsCreated EVENT OBJECT) means that OBJECT doesn't exist before EVENT but comes into existence sometime during EVENT, as a result of EVENT. #$outputsCreated is a specialization of #$nonDeliberateActors, since it would in general be impossible for OBJECT to act deliberately in its own creation.
> Cyclist Notes: See also #$creation for creations that are not instances of #$SomethingExisting
> `` (e.g., #$InformationBearingWavePropagations).
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$outputs #$startsDuring #$nonDeliberateActors
> some more specialized predicates: #$offspringActors #$iboCreated

#### #$offspringActors : <#$BiologicalReproductionEvent> <#$BiologicalLivingObject>

> (#$offspringActors EVENT ORGANISM) means that ORGANISM is an offspring created in the #$BiologicalReproductionEvent EVENT .
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$outputsCreated #$temporallyIntersects #$afterActors

#### #$products : <#$CreationOrDestructionEvent> <#$Artifact-Generic>

> (#$products EV OBJ) means that OBJ is one of the intended outputs of event EV. For unintended outputs, see #$byProducts. For a particular EV and OBJ, it will not be true that both (#$products EV OBJ) and (#$byProducts EV OBJ).
> Cyclist Notes: There is a contradiction between the #$arg2Isa #$PartiallyTangible assertion, and the rules that instances of #$Singing, #$Whistling-Human, and #$PlayingAMusicalInstrument have #$products.
> isa: #$ActorSlot
> genlPreds: #$outputs #$artifactsCreated

#### #$byProducts : <#$CreationOrDestructionEvent> <#$SomethingExisting>

> (#$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).
> isa: #$ActorSlot
> genlPreds: #$outputs
> some more specialized predicates: #$wasteProducts

#### #$iboCreated : <#$IBOCreation> <#$InformationBearingObject>

> The predicate #$iboCreated is used to link a particular information bearing object (IBO) to the event in which it is created. (#$iboCreated CREATION IBO) means that the #$InformationBearingObject IBO is created in the event CREATION. For example, my copy of today's `Austin American-Statesman' morning paper was created during the previous night's paper-publishing event.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$outputsCreated #$informationDestination #$ibtGenerated

#### #$catalyst : <#$ChemicalReaction> <#$PartiallyTangible>

> 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.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$unchangedActors

#### #$constrainingObject : <#$MovementEvent> <#$PartiallyTangible>

> (#$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.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$preActors #$postActors
> some more specialized predicates: #$transporter #$conveyor-Generic #$vehicle #$conveyor-Stationary

#### #$instrument-Generic : <#$Event> <#$PartiallyTangible>

> The predicate #$instrument-Generic is used to link a particular event to any of the objects which play an instrumental role in it. (#$instrument-Generic EVENT OBJECT) means that OBJECT plays an intermediate causal role in EVENT, facilitating its occurrence and serving some purpose of some #$Agent. This can happen in at least two ways: a. the `doer' of EVENT acts on OBJECT, which in turn acts on something else (as when someone uses a hammer to pound in a nail) or b. the `doer' of EVENT acts on something, making it possible for OBJECT to act on that thing (as when someone puts wet clothes out in the sun to dry). Typically, an #$instrument-Generic is not significantly altered by playing that role in an event. #$deviceUsed is an important specialization predicate of #$instrument-Generic.
> See #$DecidingWhichInstrumentPredicateToUse for (further) documentation.
> isa: #$ActorSlot
> genlPreds: #$actors
> some more specialized predicates: #$transporter #$instrument-Container #$stuffUsed #$programUsed #$deviceUsed #$conveyor-Generic #$vehicle #$energySource #$conveyor-Stationary

#### #$deviceUsed : <#$Event> <#$PhysicalDevice>

> The predicate #$deviceUsed indicates that a particular device is used in a particular event. (#$deviceUsed EVENT OBJECT) means that the #$PhysicalDevice OBJECT plays an instrumental role in the #$Event EVENT. (See also #$instrument-Generic.) OBJECT is intentionally used in EVENT, and standardly (e.g., in the #$HumanActivitiesMt) OBJECT's role in EVENT is consistent with the object's #$primaryFunction.
> See #$DecidingWhichInstrumentPredicateToUse for (further) documentation.
> Cyclist Notes: Assertions made in the #$HumanActivitiesMt involve no innovations in activities. In particular, assertions about a #$deviceUsed involve only usages that are consistent with the device's #$primaryFunction; i.e., tools are used for their intended purpose only (e.g., a credit card is not a #$deviceUsed to unlock a door, and a nail file is not a #$deviceUsed to unscrew a screw).
> isa: #$ActorSlot
> genlPreds: #$instrument-Generic
> some more specialized predicates: #$vehicle

#### #$instrument-Container : <#$Event> <#$Container>

> (#$instrument-Container ?EVENT ?CONT) means that the #$objectActedOn in ?EVENT is contained in (#$in-ContGeneric) ?CONT during ?EVENT, and that ?CONT facilitates ?EVENT being accomplished.
> See #$DecidingWhichInstrumentPredicateToUse for (further) documentation.
> isa: #$ActorSlot
> genlPreds: #$instrument-Generic

#### #$programUsed : <#$Action> <#$ComputerProgram>

> (#$programUsed EV PROG) means that PROG is the computer program used in the action EV.
> See #$DecidingWhichInstrumentPredicateToUse for (further) documentation.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$unchangedActors #$instrument-Generic

#### #$energySource : <#$PhysicalEvent> <#$EnergyStuff>

> This predicate is used to identify a particular source of energy used in a particular event. (#$energySource EVENT ENERGYSOURCE) means that ENERGYSOURCE provides (some of) the energy used in EVENT. ENERGYSOURCE might be a battery, the sun, a person, etc.
> See #$DecidingWhichInstrumentPredicateToUse for (further) documentation.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$stuffUsed #$temporallyIntersects

#### #$stuffUsed : <#$Event> <#$PartiallyTangible>

> The predicate #$stuffUsed relates an event to some tangible substance which facilitates that event. (#$stuffUsed EVENT STUFF) means that STUFF is a portion of an element of #$ExistingStuffType which plays an instrumental role in EVENT. STUFF may or may not be consumed in the course of EVENT. Examples: portions of #$Water are #$stuffUsed in instances of #$WashingDishes, #$WashingHair, #$WashingClothesInAMachine, etc.; portions of #$EdibleOil are #$stuffUsed in some instances of #$Frying food and #$BakingBread.
> See #$DecidingWhichInstrumentPredicateToUse for (further) documentation.
> isa: #$ActorSlot
> genlPreds: #$instrument-Generic
> some more specialized predicates: #$energySource

#### #$objectSelected : <#$SelectingSomething> <#$SomethingExisting>

> (#$objectSelected SEL OBJ) means that OBJ is the object that is chosen in the event SEL, an instance of #$SelectingSomething. If what is selected in SEL is a collection, rather than an individual object, then use the predicate #$activityObjectType to represent the object of SEL.
> isa: #$Role #$FunctionalSlot
> genlPreds: #$chosenItem

#### #$objectActedOn : <#$Event> <#$SomethingExisting>

> The predicate #$objectActedOn is used to relate an event to an entity (or entities) significantly affected in that event. That entity must exist before the event, but may be either destroyed in the event (see #$inputsDestroyed), or merely affected by it (e.g., see #$damages, #$objectOfStateChange). (#$objectActedOn EVENT OBJECT) means that OBJECT is altered or affected in EVENT, and the change that OBJECT undergoes is central or focal to understanding EVENT. Thus, scissors are NOT an #$objectActedOn in a #$HairCuttingEvent. The focal change in a haircut is hair getting shorter; thus, hair is a legitimate #$objectActedOn in a #$HairCuttingEvent. The almost microscopic dulling that scissors undergo in a single haircut is a comparatively insignificant change with respect to a single haircut, considered as a #$HairCuttingEvent.
> `` Note: long-term effects of usage on devices should be axiomatized in connection with #$UsingAFn constants.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$preActors
> some more specialized predicates: #$transportees #$inputs #$objectRemoved #$consumesPortion #$objectOfStateChange #$damages #$objectTakenCareOf #$actorPartsAffected #$objectControlled #$bodilyActedOn #$objectTested #$crewMember #$passengers #$inputsDestroyed #$inputsCommitted

#### #$objectOfStateChange : <#$IntrinsicStateChangeEvent> <#$PartiallyTangible>

> The predicate #$objectOfStateChange is used to identify the object of an instance of #$IntrinsicStateChangeEvent. (#$objectOfStateChange EVENT OBJECT) means that OBJECT is an #$Entity that undergoes some kind of intrinsic change of state in EVENT. OBJECT exists before EVENT, is directly involved in EVENT, and persists after EVENT. (Accordingly, this predicate inherits the #$genlPreds #$preActors and #$postActors through #$objectActedOn.) The change which OBJECT undergoes is internal or intrinsic; this predicate is not used for extrinsic changes, e.g., in location, orientation, ownership, status, etc. Note: If OBJECT were destroyed by EVENT and went out of existence in the course of EVENT, then the right predicate to use would be #$inputsDestroyed, rather than #$objectOfStateChange.
> isa: #$AntiTransitiveBinaryPredicate #$AsymmetricBinaryPredicate #$ActorUseTypeSlot
> genlPreds: #$objectActedOn #$postActors
> some more specialized predicates: #$birthChild #$birthParent

#### #$damages : <#$Event> <#$SomethingExisting>

> (#$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.
> isa: #$AsymmetricBinaryPredicate #$ActorUseTypeSlot
> genlPreds: #$objectActedOn
> some more specialized predicates: #$victim

#### #$objectTakenCareOf : <#$TakingCareOfSomething> <#$SomethingExisting>

> (#$objectTakenCareOf EV OBJ) means that OBJ is acted on in EV by some #$Agent in order to maintain, preserve, or promote the health
> or good condition of OBJ.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$objectActedOn #$postActors

#### #$objectControlled : <#$ControllingSomething> <#$PartiallyTangible>

> This predicate is used to indicate that a particular object is being controlled in a particular event. (#$objectControlled EVENT OBJ) means that the object OBJ is being controlled in the #$Event EVENT. Note: #$objectControlled does not assume or require physical contact between controller and object controlled.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$objectActedOn

#### #$objectRemoved : <#$RemovingSomething> <#$PartiallyTangible>

> (#$objectRemoved REMOVING OBJ) means OBJ is removed from its previous location in the removing event REMOVING. OBJ may be destroyed during REMOVING. REMOVING is #$performedBy some entity other than OBJ.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$objectActedOn

#### #$bodilyActedOn : <#$Event> <#$Organism-Whole>

> 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.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$objectActedOn
> some more specialized predicates: #$birthChild

#### #$actorPartsAffected : <#$Event> <#$OrganismPart>

> (#$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.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$objectActedOn #$nonDeliberateActors

#### #$objectTested : <#$Evaluating> <#$PartiallyTangible>

> (#$objectTested EVAL OBJ) mean that OBJ is the specific object or portion being tested in EVAL. For example, if someone has a blood test, then the object tested is the portion of blood used to run the test fulfulls the role of #$objectTested, rather than the person or the collection of that person's blood.
> isa: #$AsymmetricBinaryPredicate
> genlPreds: #$objectActedOn

#### #$doneBy : <#$Event> <#$SomethingExisting>

> The predicate #$doneBy relates an event to its `doer'. (#$doneBy EVENT DOER) means that DOER is the `doer' in the event EVENT. Some action on the part of the doer causes or carries out the event. This predicate is agnostic as to whether DOER does EVENT intentionally or not (DOER need not even be animate; e.g., the event in which Mount Vesuvius erupted and buried Pompeii was #$doneBy Mount Vesuvius). See #$performedBy and #$bodilyDoer for the more specific senses of `doer' when DOER is, respectively, an agent (#$Agent) acting deliberately or a biological organism (#$Organism-Whole).
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$preActors #$actors
> some more specialized predicates: #$senderOfInfo #$emitter #$performedBy #$bodilyDoer #$successfulForAgents #$perpetrator #$buyingPerformer #$sellingPerformer #$failureForAgents #$providerOfService #$performedByPart #$majorUndertakingsOf #$driverActor #$interviewer #$exchangers

#### #$providerOfMotiveForce : <#$MovementEvent> <#$PartiallyTangible>

> (#$providerOfMotiveForce ACT OBJ) means that OBJ provides, through its expenditure of energy, a significant fraction of the physical force required to make ACT happen. For example, if ACT is an element of #$PedalingABicycle, OBJ will be the person who is operating the bike. Another example: in the use of a belt sanding tool, there will be two values for #$providerOfMotiveForce, the electric sander and the person operating the sander. In that case, although force is transmitted and applied through the sandpaper, the paper doesn't count as a #$providerOfMotiveForce, because it only transmits force and does not itself expend energy. Note that inferences involving this constant require that every #$providerOfMotiveForce be a whole object, not just a part of an object. For example: (=> (#$and (#$isa ?LOCO #$LocomotionEvent) (#$providerOfMotiveForce ?LOCO ?OBJ)) (#$objectMoving ?LOCO ?OBJ)) or (=> (#$and (#$isa ?LOC #$LocomotionEvent) (#$providerOfMotiveForce ?LOC ?PROV)) (#$doneBy ?LOC ?PROV)) or (#$domainAssumptions #$ManualHumanActivitiesMt (#$forAll ?U (#$forAll ?PERS (#$implies (#$and (#$isa ?U #$Action) (#$providerOfMotiveForce ?U ?PERS)) (#$isa ?PERS #$Person)))))).
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$preActors
> some more specialized predicates: #$emitter #$vehicle

#### #$bodilyDoer : <#$PhysicalEvent> <#$Organism-Whole>

> 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.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$nonDeliberateActors #$doneBy
> some more specialized predicates: #$infectionHost #$birthParent

#### #$performedBy : <#$Action> <#$Agent>

> The predicate #$performedBy relates an event to an agent who performs it deliberately, which in Cyc means, intentionally and volitionally. (#$performedBy ACT DOER) means that the agent DOER deliberately does the action ACT. DOER must be an #$Agent. For example, (#$performedBy #$AssassinationOfPresidentLincoln #$JohnWilkesBooth). If ACT has multiple performers, ACT will be #$performedBy each of them. See also #$deliberateActors, #$doneBy.
> isa: #$AgentiveRole #$AsymmetricBinaryPredicate
> genlPreds: #$doneBy #$deliberateActors
> some more specialized predicates: #$successfulForAgents #$perpetrator #$buyingPerformer #$sellingPerformer #$failureForAgents #$providerOfService #$performedByPart #$majorUndertakingsOf #$driverActor #$interviewer #$exchangers #$buyingAgent #$sellingAgent #$seller #$referredServiceProvider

#### #$failureForAgents : <#$PurposefulAction> <#$Agent>

> The predicate #$failureForAgents is used to indicate that a particular agent fails to achieve (at least one of) its goals in a particular action. (#$failureForAgents ENDEAVOR AGT) means that the #$Agent AGT had some purpose in performing ENDEAVOR that was not realized. See also #$purposeInEvent.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$performedBy

#### #$successfulForAgents : <#$PurposefulAction> <#$Agent>

> The predicate #$successfulForAgents is used to indicate that a particular agent achieves its goal in a particular action. (#$successfulForAgents ENDEAVOR AGT) means that the #$Agent AGT is successful in accomplishing the #$PurposefulAction ENDEAVOR. This means that each of the purposes AGT had in doing ENDEAVOR has come true. See also #$purposeInEvent.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$performedBy #$beneficiary

#### #$majorUndertakingsOf : <#$Action> <#$Agent>

> (#$majorUndertakingsOf ACTION AGENT) means that AGENT consciously performed ACTION. The success and consequence(s) of ACTION are important to AGENT. As a result, for a sentient AGENT, failure usually results in AGENT feeling negative emotions, and success positive emotions.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$performedBy #$temporallyIntersects
> some more specialized predicates: #$competingAgents #$awardWinners #$winner-First #$contenders #$longshots #$expectedWinner

#### #$performedByPart : <#$Action> <#$Organization>

> (#$performedByPart ACT ORG) means that the #$Organization ORG is considered to be the performer of the #$Action ACT, though in fact only some subordinate part of ORG (i.e., a member or a sub-organization), rather than all of the organization, is directly involved in ACT. For example, (#$performedByPart OperationDesertStorm USArmy) since only certain divisions of the US Army participated in Operation Desert Storm.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$performedBy

#### #$socialParticipants : <#$SocialOccurrence> <#$Agent>

> (#$socialParticipants SO AGT) means that the #$Agent AGT participates --- in some social role --- in the #$SocialOccurrence SO. In every culture there are many specializations of this #$ActorSlot; some #$SocialOccurrences have very elaborate role structures (e.g., a lawsuit in 1990's America), and some are fairly simple (e.g., rudely bumping into someone.) See #$SocialOccurrence.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$preActors
> some more specialized predicates: #$prospectiveSeller #$prospectiveBuyer #$presenter #$competingAgents #$litigants #$mediators #$interviewer #$sellingPerformer #$buyingPerformer #$officiator #$hostOfEvent #$interviewee #$exchangers #$exhibitors #$payer

#### #$chairpersonOfEvent : <#$SocialGathering> <#$Person>

> (#$chairpersonOfEvent ?EV ?CHAIR) means that the #$Person ?CHAIR is the chairperson of ?EV. The #$arg1Isa, #$SocialGathering may be generalized but in the meantime keeping it possibly overspecific will help prevent divergence (i.e. will help prevent people from asserting #$chairpersonOfEvent facts about new terms that should have #$SocialGathering as their genl.
> Cyclist Notes: Re the difference
> `` between this predicate and #$chairpersonOfEvent: #$officiators include
> `` referees, priests, shamans, baliff, judge and so forth. It is hard to
> `` imagine there being more than one #$chairpersonOfEvent, and the roles of
> `` #$chairpersonOfEvent are more specific than the very broad role of
> `` #$officiator.
> isa: #$AgentiveRole #$AsymmetricBinaryPredicate
> genlPreds: #$officiator

#### #$exhibitors : <#$SocialGathering> <#$Agent>

> (#$exhibitors GATHERING AGENT) means that AGENT actively presents information, markets a product, displays merchandise or artwork to the attendees of GATHERING.
> isa: #$AgentiveRole #$AsymmetricBinaryPredicate
> genlPreds: #$socialParticipants #$deliberateActors

#### #$interviewer : <#$Interviewing> <#$Person>

> (#$interviewer INTERVIEW AGT) means that the #$Agent AGT is an interviewer in the #$Interviewing event INTERVIEW.
> isa: #$AgentiveRole #$AsymmetricBinaryPredicate
> genlPreds: #$performedBy #$socialParticipants

#### #$interviewee : <#$Interviewing> <#$Person>

> (#$interviewee INTERVIEW AGT) means that the #$Agent AGT is an interviewee in the #$Interviewing event INTERVIEW.
> isa: #$AgentiveRole #$AsymmetricBinaryPredicate
> genlPreds: #$socialParticipants

#### #$directingAgent : <#$Event> <#$Agent>

> (#$directingAgent ACT AGENT) means that AGENT is one of the agents that is in control of or directing ACT, but not necessarily directly performing it. If, in the event ACT, an agent other than AGENT has the #$performedBy role, then that performer's actions in ACT are directed by AGENT. For example, (#$directingAgent PSOBicentennialConcertOfBeethovensNinth WilliamSteinberg) is true, because Steinberg was the conductor of that concert; he directed the many other musicians who performed in that event. Another case: (#$directingAgent MassacreAtMyLai LtWilliamCalley). The type of direction implied by #$directingAgent is the kind that can be accomplished by AGENT communicating its desires to the actual performer(s) of ACT. So, a person would be the #$directingAgent in a clothes-washing event #$doneBy a washing machine ONLY in those contexts (if any) in which we can consider the machine an agent, acting intentionally.
> isa: #$AgentiveRole #$AsymmetricBinaryPredicate
> genlPreds: #$deliberateActors

#### #$hostOfEvent : <#$SocialGathering> <#$Agent>

> (#$hostOfEvent GATHERING AGENT) means that AGENT is a host and sponsor of the #$SocialGathering GATHERING.
> isa: #$AgentiveRole #$AsymmetricBinaryPredicate
> genlPreds: #$socialParticipants

#### #$presenter : <#$SocialGathering> <#$Person>

> (#$presenter GATHERING PERSON) means that PERSON speaks to a set of audience members who have a role in GATHERING.
> isa: #$AgentiveRole #$AsymmetricBinaryPredicate
> genlPreds: #$socialParticipants

#### #$officiator : <#$SocialOccurrence> <#$Agent>

> The predicate #$officiator points to the agent who performs official functions at an event. For example, it is used to indicate the person who plays the role of a priest or justice of the peace at a wedding; also, a master of ceremonies, a judge, a referee. An #$officiator is one of the performers at the social event where s/he officiates, usually not the only one.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$socialParticipants
> some more specialized predicates: #$chairpersonOfEvent

#### #$mediators : <#$SocialOccurrence> <#$Agent>

> The facilitators of a process including the agents, brokers, or mediators that assist in arranging a contract, transaction, or agreement among several parties.
> Cyclist Notes: neg ex: a sales representative who makes reservations for some kind of conference is not a mediator in that meeting.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$deliberateActors #$socialParticipants
> some more specialized predicates: #$judicialAgents #$sellingAgent #$buyingAgent

#### #$judicialAgents : <#$SocialOccurrence> <#$Agent>

> (#$judicialAgents EV JUDGE) means that the #$Agent JUDGE is acting as a judge in the event EV.
> isa: #$AgentiveRole #$AsymmetricBinaryPredicate #$AntiSymmetricBinaryPredicate #$IrreflexiveBinaryPredicate
> genlPreds: #$mediators

#### #$litigants : <#$Trial> <#$Agent>

> (litigants ARG1 ARG2) means that the agent ARG2 is one of the contending parties in the lawsuit ARG1.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$socialParticipants
> some more specialized predicates: #$plaintiffs #$defendants

#### #$plaintiffs : <#$Trial> <#$Agent>

> (plaintiffs ARG1 ARG2) means that the agent ARG2 is the complaining party (the party bringing an accusation of wrong-doing) in the lawsuit ARG1.
> isa: #$AgentiveRole #$AsymmetricBinaryPredicate
> genlPreds: #$litigants

#### #$defendants : <#$Trial> <#$Agent>

> (defendants ARG1 ARG2) means that the agent ARG2 is the accused party in the lawsuit ARG1.
> isa: #$AgentiveRole #$AsymmetricBinaryPredicate
> genlPreds: #$litigants

#### #$evaluatedAction : <#$EvaluatingAnAction> <#$Event>

> (#$evaluatedAction EVAL EVT) means that in the #$EvaluatingAnAction event EVAL, an evaluation is made of the action, event, or occurrence EVT. For example, in the evaluation of an employee, the #$evaluatedAction will be one of the job activities being #$performedBy the worker who is being evaluated.
> Cyclist Notes: This is default single entry because the rule that `whoever receives evaluation performs what is being evaluated.' works only if there is one action being evaluated. If there were many actions being evaluated, every recipient of evaluated would perform every actions being evaluated.
> isa: #$ActorSlot #$FunctionalSlot

#### #$assistingAgent : <#$Event> <#$Agent>

> (#$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.
> isa: #$AgentiveRole #$AsymmetricBinaryPredicate
> genlPreds: #$deliberateActors

#### #$buyingPerformer : <#$CommercialActivity> <#$LegalAgent>

> (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.
> isa: #$AgentiveRole #$AntiTransitiveBinaryPredicate #$AsymmetricBinaryPredicate
> genlPreds: #$socialParticipants #$performedBy
> some more specialized predicates: #$buyingAgent

#### #$buyingAgent : <#$CommercialActivity> <#$LegalAgent>

> 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.
> isa: #$AgentiveRole #$AntiTransitiveBinaryPredicate #$AsymmetricBinaryPredicate #$FunctionalSlot #$AntiSymmetricBinaryPredicate
> genlPreds: #$mediators #$buyingPerformer

#### #$sellingPerformer : <#$CommercialActivity> <#$LegalAgent>

> (sellingPerformer COM AGENT) means that the #$CommercialActivity COM is #$performedBy the #$Agent AGENT, who in that event actually pursues and attempts to make a sale. AGENT may also be (and in many cases is) the #$seller of the goods or services sold, or s/he may be the #$sellingAgent representing the #$seller.
> isa: #$AgentiveRole #$AntiTransitiveBinaryPredicate #$AsymmetricBinaryPredicate
> genlPreds: #$socialParticipants #$performedBy
> some more specialized predicates: #$sellingAgent

#### #$sellingAgent : <#$CommercialActivity> <#$LegalAgent>

> A selling agent acts on behalf of a would be seller to bring about a buying event involving his/her/its client as the seller.
> isa: #$AgentiveRole #$AntiTransitiveBinaryPredicate #$AsymmetricBinaryPredicate #$FunctionalSlot #$AntiSymmetricBinaryPredicate
> genlPreds: #$sellingPerformer #$mediators

#### #$spectators : <#$Event> <#$Agent>

> (#$spectators E AGT) means that in the #$Event E, the #$Agent AGT is an onlooker of E but not actively acting in it in any other way. AGT will observe all or part of E.
> isa: #$AgentiveRole #$AsymmetricBinaryPredicate
> genlPreds: #$preActors

#### #$providerOfService : <#$ServiceEvent> <#$Agent>

> The Cyc predicate #$providerOfService is used to relate a service to the agent that provides it. (#$providerOfService SEVT AGT) means that the #$ServiceEvent SEVT is performed or provided by the #$Agent AGT. Typically, AGT acts in order to serve the #$recipientOfService in SEVT.
> isa: #$AgentiveRole #$AsymmetricBinaryPredicate
> genlPreds: #$deliberateActors #$preActors #$performedBy
> some more specialized predicates: #$seller #$referredServiceProvider

#### #$recipientOfService : <#$ServiceEvent> <#$Agent>

> (#$recipientOfService ACT AGNT) means the #$Agent AGNT is the recipient of the #$ServiceEvent ACT. The service is performed on, for, or to AGNT, and AGNT is correspondingly affected by it.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$beneficiary #$preActors #$postActors

#### #$referredServiceProvider : <#$ServiceEvent> <#$Agent>

> The agent ARG2 who provides the service ARG1 was referred by another agent.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$providerOfService

#### #$perpetrator : <#$Action> <#$SocialBeing>

> The #$Agent(s) that performed this possibly criminal act.
> Cyclist Notes: The arg1 is left general, because acts which may be criminal are not criminal in every mt, yet we still want rules about perpetrators to apply.
> isa: #$AgentiveRole #$AsymmetricBinaryPredicate
> genlPreds: #$performedBy

#### #$victim : <#$Event> <#$SocialBeing>

> The #$Agent(s) most directly harmed by this possibly criminal act. In so-called victimless crimes, some would consider the state to be the victim, but we will not follow that convention here.
> Cyclist Notes: The arg1 is left general because acts that may be criminal will not be criminal in every mt, yet we still want rules about victims to apply.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$damages #$maleficiary

#### #$governedByAgreement : <#$SocialOccurrence> <#$Agreement>

> The predicate #$governedByAgreement relates an event to an agreement which stipulates that certain conditions are to hold during that event. (#$governedByAgreement EVT AGR) means that some aspects of the #$SocialOccurrence EVT are controlled by the #$Agreement AGR. For example, a #$BuyingGroup may have #$SalesContracts with its #$suppliers that specify what prices may be charged for goods bought by members of the group during the agreement period.
> See #$AgreementNote for (further) documentation.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$preActors

#### #$competingAgents : <#$Competition> <#$Agent>

> (#$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.
> isa: #$AgentiveRole #$AsymmetricBinaryPredicate
> genlPreds: #$socialParticipants #$majorUndertakingsOf
> some more specialized predicates: #$awardWinners #$winner-First #$contenders #$longshots #$expectedWinner

#### #$winner-First : <#$Competition> <#$Agent>

> (#$winner-First COMPETITN AGNT) means that AGNT is a first place winner of COMPETITN. The #$arg2Format of this predicate is #$SetTheFormat to allow for the uncommon (but far from `very rare') case where there is a tie for first place and two or more agents are awarded that prize. See also #$awardWinners, #$rankInCompetition, and #$competingAgents.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$competingAgents

#### #$longshots : <#$Competition> <#$Agent>

> (#$longshots COMP AGENT) indicates that AGENT, a competing agent in the #$Competition COMP, is expected NOT to win by anyone who is knowledgeable about the competition.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$competingAgents #$temporallyIntersects

#### #$expectedWinner : <#$Competition> <#$Agent>

> (#$expectedWinner ?COMP ?AGENT) indicates that ?AGENT, a competing agent of ?COMP, is expected to win by anyone who has an interest in the competition
> isa: #$AntiTransitiveBinaryPredicate #$AsymmetricBinaryPredicate #$ActorSlot #$FunctionalSlot
> genlPreds: #$contenders

#### #$awardWinners : <#$Competition> <#$Agent>

> (#$awardWinners ?competition ?agent) means that ?agent wins an award for their performance in ?competition. Typically awards are given to competitors in first, second and third place. However, sometimes awards are given only to the first place contestant or in recognition of a unique and particular strength of a given contestant's performance (e.g. sometimes awards are given for `most original'). See also #$winner-First, #$competingAgents.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$competingAgents

#### #$contenders : <#$Competition> <#$Agent>

> (#$contenders COMP AGENT) indicates that AGENT, a competing agent in the #$Competition COMP, is considered by anyone who is knowledgeable about the competition to have a good possibility of winning.
> isa: #$AsymmetricBinaryPredicate #$ActorSlot
> genlPreds: #$competingAgents
> some more specialized predicates: #$expectedWinner

#### #$wasteProducts : <#$CreationOrDestructionEvent> <#$PartiallyTangible>

> (#$wasteProducts EV OBJ) means that OBJ is one of the by-products of EV which is disposed of, rather than used or sold. See also #$unwantedMatter.
> isa: #$ActorSlot
> genlPreds: #$byProducts

### View the Actor Slot Hierarchy.

### For general information about the use of #$ActorSlots, see A Note on #$ActorSlots and Their Use

### Return to Actor Vocabulary

Search for Constants by Name (In all files, not just this one.)

Go to Top