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.)
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
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
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 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 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 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
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 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 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
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
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
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
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
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 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 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 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
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
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
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
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
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
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
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
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
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
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 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
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
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
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 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 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
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 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 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 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 ?EVENT ?ORGANISM) means that ?ORGANISM is the male parent in the #$SexualReproductionEvent ?EVENT.
isa: #$AntiTransitiveBinaryPredicate #$AsymmetricBinaryPredicate #$ActorSlot #$FunctionalSlot
genlPreds: #$parentActors
(#$femaleParentActor ?EVENT ?ORGANISM) means that ?ORGANISM is the female parent in the #$SexualReproductionEvent ?EVENT.
isa: #$AntiTransitiveBinaryPredicate #$AsymmetricBinaryPredicate #$ActorSlot #$FunctionalSlot
genlPreds: #$parentActors
(#$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 BIRTH ANIM) means that ANIM is the #$Animal that is born in the #$BirthEvent BIRTH.
isa: #$AntiTransitiveBinaryPredicate #$AsymmetricBinaryPredicate #$ActorSlot
genlPreds: #$bodilyActedOn #$objectOfStateChange
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
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 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 ?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 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
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
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
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
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
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
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 EVENT ORGANISM) means that ORGANISM is an offspring created in the #$BiologicalReproductionEvent EVENT .
isa: #$AsymmetricBinaryPredicate #$ActorSlot
genlPreds: #$outputsCreated #$temporallyIntersects #$afterActors
(#$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 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
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
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 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
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
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 ?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 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
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
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 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
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
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 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 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
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 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
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