Actor Vocabulary

A few commonly used ActorSlots are given below:

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

For a list of actor slots hierarchically arranged see Actor Slot Hierarchy.

See Complete List of ActorSlotsfor a complete list of ActorSlots

A collection of binary predicates; a specialization of #$Role. Each instance of #$ActorSlot relates some instance of #$Event to a temporal thing involved in that event (here called a participant , although the thing in question might not be playing an active role in the event). The first argument of every instance of #$ActorSlot is constrained to be an instance of some specialization of #$Event, and the second argument is constrained to be an instance of some specialization of #$SomethingExisting. All instances of #$ActorSlot have #$actors as their #$genlPreds, directly or indirectly, so that the actor slots form a kind of hierarchy. Each specialized actor slot indicates _how_ its participant participates in the event, i.e., in what role (e.g., #$inputs, #$outputs, #$doneBy). Actor slots are _not_ used to indicate the time of an event's occurrence, external representations of the event, and other more remotely related things that are not directly or indirectly involved in the occurrence of the event. Time and other quantities are relevant to events but are not instances of #$SomethingExisting; thus, they are related to events by some non-#$ActorSlot predicate. Things which are remotely related to the event -- for instance, someone who is affected by the event but doesn't exist when the event occurs -- may be related using some instance of #$Role that does not belong to #$ActorSlot, such as #$affectedAgent. See also #$Role.
guid: bd588029-9c29-11b1-9dad-c379636f7270
direct instance of: #$PredicateCategory #$AtemporalNecessarilyEssentialCollectionType
direct specialization of: #$BinaryRolePredicate  
direct generalization of: #$AgentiveRole #$ActorUseTypeSlot

Actor Slots Concerned With Agency Or Initiating An Event

This predicate relates an event to its doer . (#$doneBy EVENT DOER) means that DOER is the doer in the event EVENT: some activity on the part of DOER causes or carries out EVENT. This predicate is agnostic as to whether DOER does EVENT intentionally or not. Note that DOER need not even be animate or an agent; e.g. the event in which Mt. Vesuvius erupted and buried Pompeii was #$doneBy Mt. Vesuvius. See the specializations #$performedBy and #$bodilyDoer for cases in which the doer is, respectively, an #$Agent acting deliberately and an #$Organism-Whole behaving non-deliberately.
guid: c0fd4798-9c29-11b1-9dad-c379636f7270
direct instance of: #$ActorSlot
direct specialization of: #$preActors

An #$AgentiveRole (q.v.) predicate that relates an action (see #$Action) to an agent (see #$Agent) who performs it deliberately, i.e. intentionally and volitionally. (#$performedBy ACT DOER) means that DOER deliberately does ACT. For example, (#$performedBy #$AssassinationOfPresidentLincoln #$JohnWilkesBooth) holds. Note that an action can have multiple deliberate performers. See also the generalizations #$deliberateActors and #$doneBy.
guid: bd58a962-9c29-11b1-9dad-c379636f7270
direct instance of: #$AgentiveRole
direct specialization of: #$deliberateActors #$doneBy

The predicate #$bodilyDoer relates an instance of #$PhysicalEvent to an instance of #$Organism-Whole, where the latter is a non-deliberate doer of the former (so that the instance of #$Organism-Whole acts 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 -- for example, physical growth, peristalsis, and reflex actions -- organisms are necessarily merely #$bodilyDoers. For other actions, such as breathing, flinching, or shouting, an organism commonly (but not necessarily) acts as a #$bodilyDoer, although some cases of such events may be deliberately performed by (see the predicate #$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 #$DiabetesMellitus) 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.
guid: bd5fc61f-9c29-11b1-9dad-c379636f7270
direct instance of: #$IndividualLevelPredicate #$ActorSlot
direct specialization of: #$nonDeliberateActors #$doneBy

Actor Slots Concerned With Objects Acted On Or Changed In An Event

The predicate #$objectActedOn is used to relate an event to an entity or entities significantly affected in that event. The entity or entities in question must exist before the event, but may be either destroyed in the event (see the more specific predicate #$inputsDestroyed), or merely affected by it (for example, see the more specific predicates #$damages and #$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.
guid: bd58bae6-9c29-11b1-9dad-c379636f7270
direct instance of: #$IndividualLevelPredicate #$ActorSlot
direct specialization of: #$preActors

The predicate #$objectOfStateChange is used to identify an object undergoing a change of state in an instance of #$IntrinsicStateChangeEvent. (#$objectOfStateChange EVENT OBJECT) means that the #$PartiallyTangible OBJECT undergoes some kind of intrinsic change of state (such as a change in one of its physical properties) in the #$IntrinsicStateChangeEvent EVENT. OBJECT exists before EVENT, is directly involved in EVENT, and persists after EVENT (accordingly, this predicate has as #$genlPreds both #$preActors and #$postActors). The change which OBJECT undergoes is internal or intrinsic; this predicate is not used for extrinsic changes, such as changes in location, orientation, ownership, or status. Note that 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.
guid: bd590831-9c29-11b1-9dad-c379636f7270
direct instance of: #$ActorUseTypeSlot #$IndividualLevelPredicate
direct specialization of: #$postActors #$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 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.
guid: bd58d02b-9c29-11b1-9dad-c379636f7270
direct instance of: #$ActorSlot
direct specialization of: #$objectActedOn

Actor Slots Concerned With Objects Created Or Destroyed In An Event

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, the entity ENTITY such that (#$entitySubAbstractions OBJECT ENTITY) ends its existence as an #$Entity sometime during EVENT. (As does the OBJECT as its present instantiation of #$SomethingExisting.) For instance, suppose (#$inputsDestroyed AppleEatingEvent001 RedApple001), then the SomethingExisting, RedApple001 is destroyed in the event and, as importantly, so is the apple entity of which the red apple is a subabstraction. OBJECT may or may not be a #$deliberateActors in EVENT.
guid: bd658d50-9c29-11b1-9dad-c379636f7270
direct instance of: #$ActorSlot
direct specialization of: #$damages #$inputs

An #$ActorSlot that relates #$CreationEvents to things -- tangible objects or other enduring things (see #$SomethingExisting) -- created by those events. (#$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.
guid: bd64ad6d-9c29-11b1-9dad-c379636f7270
direct instance of: #$IndividualLevelPredicate #$ActorSlot
direct specialization of: #$eventResults #$overlapsStart #$nonDeliberateActors #$outputs

This predicate is an #$ActorSlot that relates a given event to an object or material that is used in that event and thereby either used up (i.e. destroyed) or incorporated into another object. (#$inputs EVENT OBJECT) means that OBJECT is a pre-existing participant in (see #$preActors) the #$CreationOrDestructionEvent EVENT which, during and due to EVENT, is either destroyed (see #$inputsDestroyed) or incorporated into a new entity (see #$inputsCommitted). 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 in the manufacturing process (e.g. the coke used in manufacturing steel).
guid: bd58b70d-9c29-11b1-9dad-c379636f7270
direct instance of: #$ActorSlot
direct specialization of: #$objectActedOn

This predicate relates a particular creation or destruction event to any of its outputs . (#$outputs EVENT OBJECT) means that OBJECT is an output of EVENT. That is, OBJECT is either created/produced as a result of EVENT (see the specializations #$outputsCreated, #$products, #$byProducts) or something left after another thing was destroyed in EVENT (see the specialization #$outputsRemaining). For example, silicon chips are both #$outputsCreated in and #$products of a chip manufacturing process, while a hunk of scrap metal is an #$outputsRemaining after a car is put through a crusher. When appropriate, instead of using #$outputs, use one of its specializations (of which those mentioned above are the nearest).
guid: bd589803-9c29-11b1-9dad-c379636f7270
direct instance of: #$ActorSlot
direct specialization of: #$postActors

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. Once incorporated into the output of EVENT, OBJECT can't be independently incorporated in any other creation event. For example, bricks that are used to build a wall continue to exist as bricks once the wall has been built. While a part of the wall, a brick cannot be used as an independent input in another creation event. (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.
guid: bd63edac-9c29-11b1-9dad-c379636f7270
direct instance of: #$ActorSlot
direct specialization of: #$inputs #$postActors #$commitsForFutureUses

This predicate relates physical destruction events to surviving parts of the things destroyed in those events. (#$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, the original board is destroyed and the remaining-outputs are the two smaller plywood pieces; (2) when a mixture undergoes a #$FiltrationProcess, the mixture itself is destroyed, while both the material that was in suspension (see #$suspendedPart) and the fluid it was suspended in (see #$suspendingFluid) are remaining-outputs.
guid: bd64e092-9c29-11b1-9dad-c379636f7270
direct instance of: #$ActorSlot
direct specialization of: #$preActors #$outputs

Actor Slots Concerned With Facilitating Objects Or Stuff

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 the occurrence of EVENT, and serving some purpose of some #$Agent. This can happen in at least two ways: either 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 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 of #$instrument-Generic.
guid: bd5d4eb3-9c29-11b1-9dad-c379636f7270
direct instance of: #$IndividualLevelPredicate #$ActorSlot
direct specialization of: #$actors #$instrumentalRole

The predicate #$deviceUsed relates an event to a device used in that event. (#$deviceUsed EVENT OBJECT) means that the #$PhysicalDevice OBJECT plays an instrumental role in the #$Event EVENT (see the more generalized predicate #$instrument-Generic), OBJECT is intentionally used in EVENT, and standardly (for example, in the #$HumanActivitiesMt) OBJECT's role in EVENT is consistent with the object's #$primaryFunction.
guid: bd5d0531-9c29-11b1-9dad-c379636f7270
direct instance of: #$ActorSlot
direct specialization of: #$instrument-Generic

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 instance 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.
guid: bd58cadc-9c29-11b1-9dad-c379636f7270
direct instance of: #$ActorSlot
direct specialization of: #$instrument-Generic

Which instrument predicate you use depends on what level of generality you wish your statement to apply at. One help is to look at the argument types of each instrument predicate and decide. Do you want it to apply to every #$PartiallyTangible which is an instrument? Then use #$instrument-Generic since #$PartiallyTangible is its #$arg2Isa. Are you writing a rule which really only applies to #$PhysicalDevices? Then use #$deviceUsed. But be careful! When you use a more specific predicate such as #$deviceUsed it may have special extra conditions in its definition aside from the #$PhysicalDevice #$arg2Isa constraint. Also if your first stab at the rule involves #$deviceUsed in the antecedent, see if it applies more generally to #$instrument-Generic.
guid: bd60039d-9c29-11b1-9dad-c379636f7270
direct instance of: #$SharedNote #$Individual

Actor Slots Concerned With Motion And Location

The predicate #$eventOccursAt relates a particular event to the instance of #$SpatialThing-Localized in which it occurs. (#$eventOccursAt EVENT PT) means that the spatial extent of EVENT is within PT. For example, (#$eventOccursAt LomaPrietaEarthquake SanFranciscoBayArea). Use the predicate #$eventPartiallyOccursAt to relate an event to any instance of #$SpatialThing-Localized in which some sub-event of it occurs.
guid: bd58d59e-9c29-11b1-9dad-c379636f7270
direct instance of: #$IndividualLevelPredicate #$ActorSlot
direct specialization of: #$eventPartiallyOccursAt #$eventOccursNear #$preActors

The predicate #$objectMoving relates movement events to the object or objects moving in those events. (#$objectMoving MOVE OBJECT) means that OBJECT is in motion at some point during the #$MovementEvent MOVE and is either the primary object moving (see the predicate #$primaryObjectMoving) in MOVE or the primary object moving in some sub-event (see the predicate #$subEvents) of MOVE.
guid: bd59048e-9c29-11b1-9dad-c379636f7270
direct instance of: #$ActorSlot
direct specialization of: #$transferredThing

The predicate #$transportees relates a translational motion event to the object(s) transported in that event. (#$transportees MOVE OBJ) means that some conveyance (see the predicate #$conveyor-Generic) transports OBJ in MOVE. The conveyance in question can either move along with OBJ in MOVE or remain stationary during MOVE. The conveyance in question is separate from OBJ (that is, OBJ is not a part of the conveyance).
guid: bd58ae94-9c29-11b1-9dad-c379636f7270
direct instance of: #$ActorSlot
direct specialization of: #$primaryObjectMoving #$objectActedOn

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 #$motionPathway-Complete, #$pathConnects.
guid: bd58d77a-9c29-11b1-9dad-c379636f7270
direct instance of: #$ActorSlot
direct specialization of: #$to-Generic #$postActors

This predicate is used to indicate the starting point of a particular movement from one place to another. (#$fromLocation MOVE LOC) means that LOC is where some salient moving-object (see #$objectMoving) in the #$Translocation MOVE is found at the beginning of MOVE and is where it begins this motion. This moving-object might or might not be #$Stationary at LOC at the beginning of MOVE. If MOVE is a single-pathway translation (see #$Translation-SingleTrajectory), then each of its salient moving-objects is found at LOC when MOVE starts. If MOVE has multiple movers and multiple pathways (see #$Translation-MultiTrajectory), then at least some of the moving-objects can be found at LOC when MOVE starts. If MOVE is a flow (such as a river flowing, a wind blowing, a tornado, a typhoon, some clouds moving, or air filling your lungs when you take a breath; see #$Translation-Flow), then at least some portion of the fluid moving-object can be found at LOC when MOVE starts. See also #$motionPathway-Complete and #$pathConnects.
guid: bd58e223-9c29-11b1-9dad-c379636f7270
direct instance of: #$ActorSlot
direct specialization of: #$preActors #$from-Generic

This predicate can be used to indicate that the trajectory or trajectories travelled by one or more objects during a movement event follow some spatial path throughout the entire movement. More formally, if MOVE is an instance of #$Translation-SingleTrajectory, (#$motionPathway-Complete MOVE PATH) means that the instance PATH of #$Path-Spatial contains the entire instance of #$Trajectory along which the objects moving (see #$objectMoving) travel in MOVE. Note that there can be at most one #$motionPathway-Complete in this case. If MOVE is an instance of #$Translation-MultiTrajectory, (#$motionPathway-Complete MOVE PATH) means that the instance PATH of #$Path-Spatial contains the entire instance of #$Trajectory along which at least one of the objects moving in MOVE travels. In this case, more than one #$motionPathway-Complete may exist. (Note that the instance of #$Traversal determined by the #$trajectory-Complete need not occupy the whole length of PATH.) To explain this predicate somewhat differently, any #$motionPathway-Complete of an instance of #$Movement-TranslationEvent connects the starting and stopping points (the #$fromLocation and #$toLocation) of the whole trajectory of at least one object in the movement event (See also #$pathConnects). Note that PATH may be a marked or unmarked instance of #$Path-Spatial. See also #$trajectoryPassesThrough and #$motionPathway-Partial. You can use #$trajectoryPassesThrough to state that an object passes through a particular location on the object's trajectory.
guid: bd58827b-9c29-11b1-9dad-c379636f7270
direct instance of: #$ActorSlot
direct specialization of: #$genericPathway-Complete #$motionPathway-Partial

This predicate can be used to indicate one of the paths followed in some movement event. More formally, (#$motionPathway-Partial MOVE PATH) means that the instance MOVE of #$Movement-TranslationEvent has a trajectory (see #$trajectory-Complete) with a sub-trajectory in common with some #$subPaths of the instance PATH of #$Path-Spatial. For example, if a certain trip to Dallas from Austin is via highway I-35, this does not imply 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. Contrast this predicate with #$motionPathway-Complete, which indicates the relation between a movement MOVE and an instance of #$Path-Spatial followed throughout all of MOVE.
guid: bff40598-9c29-11b1-9dad-c379636f7270
direct instance of: #$ActorSlot
direct specialization of: #$genericPathway-Partial

Some Very General Actor Slots

The most general instance of #$ActorSlot (q.v.): all other actor slots are specializations of this predicate. Thus #$actors is a broad relation that holds between a given event and any contemporary existing thing (see #$SomethingExisting) that is meaningfully involved in the event. (#$actors EVENT ACTOR) means that ACTOR is somehow saliently (directly or indirectly) involved in EVENT during EVENT. An object's merely being cotemporal (see #$cotemporal) with an event is obviously not sufficient for being an actor in it, nor is participating (however centrally) in a representation or re-enactment of the event. But note that being an actor in the sense is _not_ restricted to things that play active (as opposed to passive or instrumental) roles in a given event.
guid: bd58c5a5-9c29-11b1-9dad-c379636f7270
direct instance of: #$ActorSlot
direct specialization of: #$temporallyIntersects #$constituentInSituation

An #$ActorSlot (q.v.) that relates an event to those of its participants that pre-exist it. (#$preActors EVENT OBJECT) means that OBJECT is a participant (see #$actors) in EVENT and that OBJECT exists before EVENT begins. Note that OBJECT also exists during at least part of EVENT (as #$actors generalizes to #$temporallyIntersects). #$preActors is a very general actor-slot, subsuming #$doneBy, #$objectActedOn, #$objectMoving, and many others.
guid: bd60ca59-9c29-11b1-9dad-c379636f7270
direct instance of: #$ActorSlot
direct specialization of: #$startsAfterStartingOf #$actors

The predicate #$postActors is used to indicate that a participant in an event continues to exist after that event is over. (#$postActors EVENT OBJECT) means that OBJECT is a participant in EVENT (so that (#$actors EVENT OBJECT) also holds), and that OBJECT exists after EVENT ends. #$postActors is a very general instance of #$ActorSlot; it subsumes #$outputsCreated, #$transferredThing, and many others.
guid: bd5e52a6-9c29-11b1-9dad-c379636f7270
direct instance of: #$ActorSlot
direct specialization of: #$actors