; Fri Nov 07 22:02:17 CST 2003
; 
;+ (version "1.9")
;+ (build "Build 1120")


(defclass %3ACLIPS_TOP_LEVEL_SLOT_CLASS
	(is-a USER)
	(role concrete)
	(multislot follows
;+		(comment "When one interval starts after another ends.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(inverse-slot precedes)
		(create-accessor read-write))
	(single-slot end+time
;+		(comment "Like start_time, but the other end of the interval.  Likewise start_time, not ready to commit to integer vs. class for the value here.")
;+		(type ANY)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(multislot start
;+		(comment "Designates a starting point for a cyclic process.  This avoids the requirement to represent cyclic processes with a cyclic graph.  Not impossible to deal with, but adds unnecessary complexity.")
		(type INSTANCE)
;+		(allowed-classes Process)
		(create-accessor read-write))
	(multislot actor
;+		(comment "An agent, generally living, causally related to the event.  The causal relationship specifies the event as an action.")
		(type INSTANCE)
;+		(allowed-classes Biological)
		(create-accessor read-write))
	(multislot synchronous
;+		(comment "The idea is two complex or cyclic complex events that maintain phase as they proceed.")
		(type INSTANCE)
;+		(allowed-classes)
;+		(inverse-slot synchronous)
		(create-accessor read-write))
	(multislot object
;+		(comment "The \"direct\" object slot for an action.  If a turtle uses a flipper to move stand, the flipper is the instrument, which moves the object - sand.  Note: cases of moving a body part may be best treated by assigning the part moved to the object slot, with something more proximal serving as the instrument - move_head ought to be modelled as object:head; instrument:neck.")
		(type INSTANCE)
;+		(allowed-classes Tangible)
		(create-accessor read-write))
	(single-slot normal_termination
;+		(comment "A state that holds when the script is \"successfully completed.\"  This might serve as the basis for reasoning about goals.")
		(type INSTANCE)
;+		(allowed-classes State)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(multislot simultaneous
;+		(comment "Two intervals that share start and end points (?).  This should be a symmetric relation.")
		(type INSTANCE)
;+		(allowed-classes)
;+		(inverse-slot simultaneous)
		(create-accessor read-write))
	(single-slot interruption
;+		(comment "An event that results in the script not reaching the goal state.")
		(type INSTANCE)
;+		(allowed-classes Event)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(single-slot start+time
;+		(comment "The first time when an event is happening (holds).  This might be an integer or a class.")
;+		(type ANY)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(single-slot precedes
;+		(comment "When one interval ends before another starts.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
;+		(inverse-slot follows)
		(create-accessor read-write))
	(multislot instrument
;+		(comment "Will usually be a body part, but could be a tool.  Potentially multiple instruments or a kinematic chain may be necessary.  Also see comments for object slot.")
		(type INSTANCE)
;+		(allowed-classes)
		(create-accessor read-write))
	(single-slot caused_by
;+		(comment "This slot is a causal link back from an event to another event.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 1 1)
		(create-accessor read-write)))

(defclass Process "A process is any sort of temporal object: an event, a state or a sequence of events and states.  In this ontology, time is represented as intervals.  As has been pointed out numerous times, this is equivalent to representing time as points, but lead to a different view of things.  PEM"
	(is-a Intangible)
	(role abstract)
	(multislot follows
;+		(comment "When one interval starts after another ends.")
		(type INSTANCE)
;+		(allowed-classes Process)
		(create-accessor read-write))
	(single-slot contained_in
;+		(comment "This slot should definitely behave differently for different classes - for example physical objects and information.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(single-slot end+time
;+		(comment "Like start_time, but the other end of the interval.  Likewise start_time, not ready to commit to integer vs. class for the value here.")
		(type INSTANCE)
;+		(allowed-classes Temporal_measure)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(multislot simultaneous
;+		(comment "Two intervals that share start and end points (?).  This should be a symmetric relation.")
		(type INSTANCE)
;+		(allowed-classes Process)
		(create-accessor read-write))
	(single-slot start+time
;+		(comment "The first time when an event is happening (holds).  This might be an integer or a class.")
		(type INSTANCE)
;+		(allowed-classes Temporal_measure)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(single-slot precedes
;+		(comment "When one interval ends before another starts.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(multislot parts
;+		(comment "The inverse of part_of.  This should be a list of all of the things that claim to be part_of this object.")
		(type INSTANCE)
;+		(allowed-classes Process)
		(create-accessor read-write))
	(multislot synchronous
;+		(comment "The idea is two complex or cyclic complex events that maintain phase as they proceed.")
		(type INSTANCE)
;+		(allowed-classes Process)
		(create-accessor read-write))
	(single-slot part_of
;+		(comment "This \"part_of\" relation usually implies temporal inclusion.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(multislot contains
;+		(comment "Events contained within, but not essential to, a larger event.")
		(type INSTANCE)
;+		(allowed-classes Process)
		(create-accessor read-write)))

(defclass Event "An event is a type of temporal object (one where something is assumed to happen). PEM"
	(is-a Process)
	(role concrete)
	(single-slot follows
;+		(comment "When one interval starts after another ends.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(single-slot precedes
;+		(comment "When a temporal interval ends before another starts.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(single-slot synchronous
;+		(comment "The idea is two complex or cyclic complex events that maintain phase as they proceed.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(single-slot part_of
;+		(comment "This \"part_of\" relation usually implies temporal inclusion.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(multislot object
;+		(comment "The \"direct\" object slot for an action.  If a turtle uses a flipper to move stand, the flipper is the instrument, which moves the object - sand.  Note: cases of moving a body part may be best treated by assigning the part moved to the object slot, with something more proximal serving as the instrument - move_head ought to be modelled as object:head; instrument:neck.")
		(type INSTANCE)
;+		(allowed-classes Tangible)
		(create-accessor read-write)))

(defclass Action "Actions are events for which there exists some responsible party or parties. PEM"
	(is-a Event)
	(role abstract)
	(single-slot follows
;+		(comment "When one interval starts after another ends.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(multislot actor
;+		(comment "An agent, generally living, causally related to the event.  The causal relationship specifies the event as an action.")
		(type INSTANCE)
;+		(allowed-classes Organism)
		(create-accessor read-write))
	(single-slot synchronous
;+		(comment "The idea is two complex or cyclic complex events that maintain phase as they proceed.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(single-slot function_of
;+		(comment "Connects an action to its explantion in terms of a function.")
		(type INSTANCE)
;+		(allowed-classes Functional_explanation)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(single-slot precedes
;+		(comment "When a temporal interval ends before another starts.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(multislot instrument
;+		(comment "Will usually be a body part, but could be a tool.")
		(type INSTANCE)
;+		(allowed-classes Physical_object)
		(create-accessor read-write))
	(single-slot part_of
;+		(comment "This \"part_of\" relation usually implies temporal inclusion.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write)))

(defclass Action_group "Loose umbrella term for associated collections of actions.  PEM."
	(is-a Action)
	(role abstract))

(defclass Action_Pattern "A characteristic sequence of simple actions.  A generic term intended to include more specific notions such as 'fixed action pattern' and 'modal action pattern' (Barlow 1977). PEM"
	(is-a Action_group)
	(role abstract)
	(single-slot follows
;+		(comment "When one interval starts after another ends.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(multislot actor
;+		(comment "An agent, generally living, causally related to the event.  The causal relationship specifies the event as an action.")
		(type INSTANCE)
;+		(allowed-classes Organism)
		(create-accessor read-write))
	(multislot parts
;+		(comment "The inverse of part_of.  This should be a list of all of the things that claim to be part_of this object.")
		(type INSTANCE)
;+		(allowed-classes Process)
		(create-accessor read-write))
	(single-slot synchronous
;+		(comment "The idea is two complex or cyclic complex events that maintain phase as they proceed.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(single-slot precedes
;+		(comment "When a temporal interval ends before another starts.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(multislot instrument
;+		(comment "Will usually be a body part, but could be a tool.")
		(type INSTANCE)
;+		(allowed-classes Physical_object)
		(create-accessor read-write))
	(single-slot part_of
;+		(comment "This \"part_of\" relation usually implies temporal inclusion.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write)))

(defclass Script_phase "A collection of actions that are characteristically strung together in a script.  PEM"
	(is-a Action_group)
	(role concrete))

(defclass Action_unit "The simplest description of an action within the ontology.  It should reflect the lowest level of description in the source ethogram or as selected by the behavior coder."
	(is-a Action)
	(role abstract))

(defclass Topological_change "A change in the topological connectedness of the organism.  Note: Although animals with complete guts are topologically donut-like (or worse), behaviorally, they are better modeled as being hollow most of the time and occasionally changing their connectedness at one end or the other.  This simplification seems to generalize well. PEM"
	(is-a Action_unit)
	(role abstract))

(defclass Close "Cut off an inner volume from the outside by (re)joining the edges of a surface.  PEM"
	(is-a Topological_change)
	(role concrete))

(defclass Engulf "Force an external object into an internal cavity, then close the cavity.  PEM"
	(is-a Topological_change)
	(role concrete))

(defclass Expel "Open a cavity containing material or an object to the outside, then force the material away from the surface of the cavity.  PEM"
	(is-a Topological_change)
	(role concrete))

(defclass Open "Divide a surface, allowing an inner volume access to the outside.  PEM"
	(is-a Topological_change)
	(role concrete))

(defclass Shape_change "Most animal actions neither change their topology, nor change the properties of their surface - Shape_change currently covers everything else.  PEM"
	(is-a Action_unit)
	(role abstract))

(defclass Rotation "Object turning around an axis that passes through its center. PEM"
	(is-a Shape_change)
	(role abstract))

(defclass Folding "An object turning around an axis that does not pass through its center.  Hinges are common examples.  PEM."
	(is-a Shape_change)
	(role abstract))

(defclass Surface_change "A change in a property of the surface of an animal.  Piloerection has some component of this.  Color change in squid is a better example.  PEM."
	(is-a Action_unit)
	(role abstract))

(defclass Event_by_cause "Event categorized by the type of Process that caused it.  PEM"
	(is-a Event)
	(role abstract)
	(single-slot caused_by
;+		(comment "This slot is a causal link back from an event to another event.  Members of Event_by_cause ought to specify the cause that got them added to this class.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 1 1)
		(create-accessor read-write)))

(defclass Effect_of_action "Effect caused by an action; effect may operate on either the actor associated with the actor or something else.  PEM."
	(is-a Event_by_cause)
	(role concrete)
	(single-slot caused_by
;+		(comment "This slot is a causal link back from an event to another event.  Members of Event_by_action ought to specify the action that got them added to this class.")
		(type INSTANCE)
;+		(allowed-classes Action)
;+		(cardinality 1 1)
		(create-accessor read-write)))

(defclass Effect_of_external_agent "Effect of action performed by an actor different from the object of action.  PEM"
	(is-a Event_by_cause)
	(role concrete)
	(multislot actor
;+		(comment "An agent, generally living, causally related to the event.  The causal relationship specifies the event as an action.")
		(type INSTANCE)
;+		(allowed-classes Biological)
		(create-accessor read-write)))

(defclass Effect_of_inanimate_process "Effect caused by an inanimate process e.g., wave action or gravity.  PEM."
	(is-a Event_by_cause)
	(role concrete))

(defclass Event_by_consequence "Event categorized by its effect."
	(is-a Event)
	(role concrete))

(defclass Event_with_reproductive_consequence "An event that results in changes in the reproductive outcome or output of an individual.  PEM"
	(is-a Event_by_consequence)
	(role concrete))

(defclass Reproductive_loss "Event leading to death or destruction of offspring or gametes."
	(is-a Event_with_reproductive_consequence)
	(role concrete))

(defclass State "Sort of the complement to events.  Since states 'hold' over an interval, they are also temporal objects. PEM"
	(is-a Process)
	(role abstract)
	(single-slot follows
;+		(comment "When one interval starts after another ends.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(single-slot precedes
;+		(comment "When a temporal interval ends before another starts.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(single-slot synchronous
;+		(comment "The idea is two complex or cyclic complex events that maintain phase as they proceed.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(single-slot part_of
;+		(comment "This \"part_of\" relation usually implies temporal inclusion.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(multislot object
;+		(comment "The \"direct\" object slot for an action.  If a turtle uses a flipper to move stand, the flipper is the instrument, which moves the object - sand.  Note: cases of moving a body part may be best treated by assigning the part moved to the object slot, with something more proximal serving as the instrument - move_head ought to be modelled as object:head; instrument:neck.")
		(type INSTANCE)
;+		(allowed-classes Tangible)
		(create-accessor read-write)))

(defclass Sequence "A temporally ordered set of events. PEM"
	(is-a Process)
	(role concrete)
	(single-slot synchronous
;+		(comment "The idea is two complex or cyclic complex events that maintain phase as they proceed.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(single-slot part_of
;+		(comment "This \"part_of\" relation usually implies temporal inclusion.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write)))

(defclass Script "For handling more complex sequences of actions with multiple actors.  This is similar to the original notion of scripts in Schank and Abelson (1977), but can also have some properties of a goal."
	(is-a Sequence)
	(role concrete)
	(single-slot follows
;+		(comment "When one interval starts after another ends.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(single-slot normal_termination
;+		(comment "A state that holds when the script is \"successfully completed.\"  This might serve as the basis for reasoning about goals.")
		(type INSTANCE)
;+		(allowed-classes State)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(single-slot interruption
;+		(comment "An event that results in the script not reaching the goal state.")
		(type INSTANCE)
;+		(allowed-classes Event)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(single-slot precedes
;+		(comment "When a temporal interval ends before another starts.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(multislot parts
;+		(comment "The elements that make up a script.  Somehow it would be nice to fill these automatically with defaults when a script instance is created.")
		(type INSTANCE)
;+		(allowed-classes Process)
		(create-accessor read-write))
	(single-slot synchronous
;+		(comment "The idea is two complex or cyclic complex events that maintain phase as they proceed.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(single-slot part_of
;+		(comment "This \"part_of\" relation usually implies temporal inclusion.")
		(type INSTANCE)
;+		(allowed-classes Process)
;+		(cardinality 0 1)
		(create-accessor read-write)))

(defclass Repeating_sequence "Sequence of events that (potentially) cycles.  Because instances of this cycle by default, a start point and termination or interruption conditions are appropriate.  PEM."
	(is-a Sequence)
	(role concrete)
	(multislot start
;+		(comment "Designates a starting point for a cyclic process.  This avoids the requirement to represent cyclic processes with a cyclic graph.  Not impossible to deal with, but adds unnecessary complexity.")
		(type INSTANCE)
;+		(allowed-classes Action)
		(create-accessor read-write))
	(single-slot normal_termination
;+		(comment "A state that holds when the script is \"successfully completed.\"  This might serve as the basis for reasoning about goals.")
		(type INSTANCE)
;+		(allowed-classes State)
;+		(cardinality 0 1)
		(create-accessor read-write))
	(single-slot interruption
;+		(comment "An event that results in the script not reaching the goal state.")
		(type INSTANCE)
;+		(allowed-classes Event)
;+		(cardinality 0 1)
		(create-accessor read-write)))

(defclass Action_sequence "A sequential set of actions that is not characteristic of an actor or species (compare action_pattern).  PEM"
	(is-a Action_group Sequence)
	(role abstract))

(defclass Simple_script "Script-like sequence of actions with a single actor.  This covers sea turtle nesting, but not courtship for example.  A human example might be getting food from a vending machine versus visiting a restaurant.  PEM"
	(is-a Script Action_sequence)
	(role concrete))