## Actor Vocabulary

E-Mail Comments to: opencyc-doc@cyc.com
Last Update: 4/5/02
Copyright© 1996-2002. All rights reserved. See Terms of Usage.

Return to Documentation Contents
Return to Vocabulary Contents

### 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

#$ActorSlot actor slots

> 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
> direct specialization of: #$BinaryRolePredicate
> direct generalization of: #$AgentiveRole #$ActorUseTypeSlot

### Actor Slots Concerned With Agency Or Initiating An Event

#$doneBy doer (actor slot) **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> 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

#$performedBy performer (actor slot)

> This predicate relates an action to an agent who performs it deliberately, i.e. intentionally and volitionally. (#$performedBy ACT DOER) means that DOER deliberately does the #$Action ACT. For example, (#$performedBy #$AssassinationOfPresidentLincoln #$JohnWilkesBooth) holds. Note that an event 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

#$bodilyDoer bodily doer (actor slot) **GAFs NOT REVIEWED**

> 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

#$objectActedOn affected object (actor slot)

> 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

#$objectOfStateChange object of state change (actor use type slot)

> 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: #$IndividualLevelPredicate #$ActorUseTypeSlot
> direct specialization of: #$postActors #$objectActedOn

#$bodilyActedOn agent physically acted on **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> 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

#$inputsDestroyed thing destroyed **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> 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

#$outputsCreated output created (actor slot) **GAFs NOT REVIEWED**

> 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: #$ActorSlot #$IndividualLevelPredicate
> direct specialization of: #$eventResults #$nonDeliberateActors #$outputs

#$inputs input (actor slot) **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> 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

#$outputs output

> 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

#$inputsCommitted input incorporated into the end result **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> 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

#$outputsRemaining output remaining afterwards **GAFs NOT REVIEWED**

> 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

#$instrument-Generic instrument (actor slot)

> 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

#$deviceUsed device used (actor slot)

> 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

#$stuffUsed stuff used **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> 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

#$DecidingWhichInstrumentPredicateToUse deciding which instrument predicate to use **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> 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: #$Individual

### Actor Slots Concerned With Motion And Location

#$eventOccursAt location (actor slot) **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> 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

#$objectMoving moving object (actor slot) **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

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

#$transportees transportee (actor slot) **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> The predicate #$transportees relates a translational motion event to the object(s) transported by a separate object, i.e. a distinctly separate other participant in the event. (#$transportees MOVE OBJ) means that some #$conveyor-Generic 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. In other words, #$transporters only transport separate objects. #$translatesFromTo on the other hand, does apply to parts of #$transportees. Note also that parts of #$transportees are not necessarily #$transportees themselves. See also the comments on #$TransportationEvent and #$transporter.
> guid: bd58ae94-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ActorSlot
> direct specialization of: #$primaryObjectMoving #$objectActedOn

#$toLocation destination (actor slot) **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> 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

#$fromLocation origin **GAFs NOT REVIEWED**

> 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

#$motionPathway-Complete path cospatial with the path of motion **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> 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

#$motionPathway-Partial path overlapping the path of motion **COMMENT NOT REVIEWED** **GAFs NOT REVIEWED**

> 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

#$actors actor (actor slot) **GAFs NOT REVIEWED**

> 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

#$preActors pre-existing actor (actor slot) **GAFs NOT REVIEWED**

> This predicate 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. In most cases, OBJECT also exists during at least part of EVENT (see #$temporallyIntersects). #$preActors is a very general #$ActorSlot, subsuming #$doneBy, #$objectActedOn, #$objectMoving, and many others.
> guid: bd60ca59-9c29-11b1-9dad-c379636f7270
> direct instance of: #$ActorSlot
> direct specialization of: #$startsAfterStartingOf #$actors

#$postActors actor remaining afterwards (actor slot)

> 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

Copyright© 1996-2002. All rights reserved. See Terms of Usage.