(In-Package "ONTOLINGUA-USER")

;;; Written by user Iwh from session "Session name not supplied [Wednesday,  6 September 1995, 02:02:14]" owned by group JUST-ME
;;; Date: Sep 7, 1995  07:41


(Define-Ontology
     Epml
     (Enterprise-V0.1)
   "EPML (Enterprise Process Modelling Language) is the process modelling 
ontology for the <a href=\"http://www.aiai.ed.ac.uk/~entprise/\">
Enterprise Project </a>.

<p>

EPML is an extension to the Activity Ontology part of the Enterrpise
ontology. EPML was developed to allow process models to be
represented and enacted within the Enterprise toolkit. EPML is an
extension to the Enterprise ontology, in that it is subclassed off
terms in the Enterprise ontology, such as activity-specification,
actor and resource.

<p>

The motivation behind developing EPML was that the Enterpise ontology was 
found not expressive enough to be used in the Task Manager part of the 
Enterprise toolkit. This was especially true in the area of constraints 
(see below). Feedback from the development of EPML has resulted in some of 
the ideas being incorporated into the later versions of the Enterprise 
Ontology. EPML though has been adopted for use as the ontology that the 
Task Manager in Enterprise will use."
   :Io-Package
   "ONTOLINGUA-USER")


(In-Ontology (Quote Epml))



;;; Epml-Available

(Define-Instance Epml-Available (Epml-Activity-State Epml-Actor-State Epml-Resource-State) "Specifies that the status of an entity is available, i.e. it is not allocated") 


;;; Epml-Resource-Activities

(Define-Frame Epml-Resource-Activities :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range Epml-Activity) (Domain Epml-Resource) (Documentation "The activity which creates, modifies, uses or consumes the resource."))) 


;;; Epml-Actor-Capability-Condition

(Define-Frame Epml-Actor-Capability-Condition :Own-Slots ((Instance-Of Class) (Subclass-Of State-Of-Affairs) (Documentation "This defines a restricted subset of State-Of-Affairs, where the relationship is of type Epml-Actor-Capability")) :Axioms (<=> (Epml-Actor-Capability-Condition ?Soa) (Restricted-List-Of-Relsents ?Soa (Quote (Epml-Actor-Capability))))) 


;;; Epml-Group

(Define-Frame Epml-Group :Own-Slots ((Arity 1) (Instance-Of Class) (Subclass-Of Epml-Actor) (Documentation "An abstract class to define types of groups, e.g.
team, business unit, organisation")) :Template-Slots ((Epml-Group-Members (Slot-Value-Type Epml-Person) (Minimum-Slot-Cardinality 0)))) 


;;; Epml-Pre-Condition

(Define-Frame Epml-Pre-Condition :Own-Slots ((Instance-Of Class) (Subclass-Of Pre-Condition) (Exhaustive-Subclass-Partition :Value (Setof Epml-Input-Activity-Status-Constraint Epml-Input-Resource-Status-Constraint Epml-Actor-Capability-Constraint Epml-Actor-Authority-Constraint Epml-Actor-Status-Constraint)) (Documentation "The Pre-Condition in a Specified-Pre-Condition
relationship with some Activity"))) 


;;; Epml-Completed

(Define-Instance Epml-Completed (Epml-Activity-State) "Specifies that the activity is completed") 


;;; Epml-Suspended

(Define-Instance Epml-Suspended (Epml-Activity-State) "Specifies that the activity is suspended") 


;;; Epml-Resource

(Define-Frame Epml-Resource :Own-Slots ((Arity 1) (Instance-Of Class) (Subclass-Of Resource) (Documentation "Epml-Resource is used as an abstract parent class for
more specific resources. It is the root of a is_a hierarchy for all domain
objects, which can be viewed as potential resources")) :Template-Slots ((Epml-Resource-Name (Slot-Value-Type String) (Slot-Cardinality 1)) (Epml-Resource-Status (Slot-Value-Type Epml-Resource-State) (Slot-Cardinality 1)) (Epml-Resource-Location (Slot-Value-Type String) (Minimum-Slot-Cardinality 1)) (Epml-Resource-Ownership (Slot-Value-Type Epml-Actor) (Minimum-Slot-Cardinality 0)) (Epml-Resource-Activities (Slot-Value-Type Epml-Activity) (Minimum-Slot-Cardinality 0)))) 


;;; Epml-Actor-Condition

(Define-Frame Epml-Actor-Condition :Own-Slots ((Instance-Of Class) (Subclass-Of State-Of-Affairs) (Documentation "This defines a restricted subset of State-Of-Affairs, where the relationship is of type Epml-Actor-Status")) :Axioms (<=> (Epml-Actor-Condition ?Soa) (Restricted-List-Of-Relsents ?Soa (Quote (Epml-Actor-Status))))) 


;;; Epml-Allocated

(Define-Instance Epml-Allocated (Epml-Activity-State Epml-Actor-State Epml-Resource-State) "Specifies that the status of an entity is allocated, i.e. it is not available") 


;;; Epml-Activity-Successor

(Define-Frame Epml-Activity-Successor :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range Epml-Activity) (Domain Epml-Activity) (Documentation "An activity is a successor of another activity if
the successor activity begins after the activity completes and no
other activities occur between them."))) 


;;; Epml-Activity-Resource

(Define-Frame Epml-Activity-Resource :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range Epml-Resource) (Domain Epml-Activity) (Documentation "A relationship between an activity and a resource
whereby the activity creates, modifies, uses or consumes the resource."))) 


;;; Epml-Resource-Ownership

(Define-Frame Epml-Resource-Ownership :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range Epml-Actor) (Domain Epml-Resource) (Documentation "A relationship between a resource and an actor
whereby the resource is owned by the actor."))) 


;;; Epml-Resource-Status

(Define-Frame Epml-Resource-Status :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range Epml-Resource-State) (Domain Epml-Resource) (Documentation "The status of a resource."))) 


;;; Epml-Broken

(Define-Instance Epml-Broken (Epml-Activity-State) "Specifies that the activity is broken") 


;;; Epml-Input-Resource-Status-Constraint

(Define-Frame Epml-Input-Resource-Status-Constraint :Own-Slots ((Instance-Of Class) (Subclass-Of Epml-Pre-Condition) (Documentation "The necessary state values that a resource must 
have for an activity to be started")) :Template-Slots ((State-Description (Slot-Value-Type Epml-Resource-Condition) (Slot-Cardinality 1)))) 


;;; Epml-Activity-Owner

(Define-Frame Epml-Activity-Owner :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range Epml-Actor) (Domain Epml-Activity) (Documentation "A relationship between an activity and an actor
whereby the activity is owned by the actor."))) 


;;; Epml-Resource-State

(Define-Frame Epml-Resource-State :Own-Slots ((Arity 1) (Instance-Of Class) (Subclass-Of Misc-Spec-Detail) (Documentation "A specification of the state of a Epml-Resource"))) 


;;; Epml-Actor-State

(Define-Frame Epml-Actor-State :Own-Slots ((Arity 1) (Instance-Of Class) (Subclass-Of Misc-Spec-Detail) (Documentation "A specification of the state of an Epml-Actor"))) 


;;; Epml-Actor-Capability-Constraint

(Define-Frame Epml-Actor-Capability-Constraint :Own-Slots ((Instance-Of Class) (Subclass-Of Epml-Pre-Condition) (Documentation "A capability that an actor requires to execute 
an activity")) :Template-Slots ((State-Description (Slot-Value-Type Epml-Actor-Capability-Condition) (Slot-Cardinality 1)))) 


;;; Epml-Output-Activity-Status-Constraint

(Define-Frame Epml-Output-Activity-Status-Constraint :Own-Slots ((Instance-Of Class) (Subclass-Of Epml-Effect) (Documentation "The status that the activity will have if it has been
completed succesfully")) :Template-Slots ((State-Description (Slot-Value-Type Epml-Activity-Condition) (Slot-Cardinality 1)))) 


;;; Epml-Activity-Doer

(Define-Frame Epml-Activity-Doer :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range Epml-Actor) (Domain Epml-Activity) (Documentation "A relationship between an activity and an actor
whereby the activity is done by the actor."))) 


;;; Epml-Actor-Status-Constraint

(Define-Frame Epml-Actor-Status-Constraint :Own-Slots ((Instance-Of Class) (Subclass-Of Epml-Pre-Condition) (Documentation "The status that an actor must have for an activity to be started")) :Template-Slots ((State-Description (Slot-Value-Type Epml-Actor-Condition) (Slot-Cardinality 1)))) 


;;; Epml-Actor-Authority

(Define-Frame Epml-Actor-Authority :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range Epml-Activity) (Domain Epml-Actor) (Documentation "A relationship between an Epml-Actor and a
Epml-Activity whereby the Epml-Actor has the authority to perform 
the Epml-Activity"))) 


;;; Epml-Actor-Capability

(Define-Frame Epml-Actor-Capability :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range Epml-Activity) (Domain Epml-Actor) (Documentation "A relationship between an Epml-Actor and a
Epml-Activity whereby the Epml-Actor is capable of performing 
the Epml-Activity"))) 


;;; Epml-Activity

(Define-Frame Epml-Activity :Own-Slots ((Instance-Of Class) (Subclass-Of Activity-Spec) (Documentation "")) :Template-Slots ((Epml-Activity-Name (Slot-Value-Type String) (Slot-Cardinality 1)) (Epml-Activity-Status (Slot-Value-Type Epml-Activity-State) (Slot-Cardinality 1)) (Epml-Activity-Predecessor (Slot-Value-Type Epml-Activity) (Minimum-Slot-Cardinality 0)) (Epml-Activity-Successor (Slot-Value-Type Epml-Activity) (Minimum-Slot-Cardinality 0)) (Epml-Activity-Component (Slot-Value-Type Epml-Activity) (Minimum-Slot-Cardinality 0)) (Epml-Activity-Doer (Slot-Value-Type Epml-Actor) (Minimum-Slot-Cardinality 0)) (Epml-Activity-Owner (Slot-Value-Type Epml-Actor) (Minimum-Slot-Cardinality 0)) (Epml-Activity-Resource (Slot-Value-Type Epml-Resource) (Minimum-Slot-Cardinality 0)) (Epml-Activity-Interval (Slot-Value-Type Time-Range) (Slot-Cardinality 1)) (Epml-Specified-Pre-Condition (Slot-Value-Type Epml-Pre-Condition) (Minimum-Slot-Cardinality 0)) (Epml-Specified-Effect (Slot-Value-Type Epml-Effect) (Minimum-Slot-Cardinality 0)))) 


;;; Epml-Document

(Define-Frame Epml-Document :Own-Slots ((Arity 1) (Instance-Of Class) (Subclass-Of Epml-Resource) (Documentation "An abstract class to define types of documents which
are used, modified, created or consumed bt tasks."))) 


;;; Epml-Actor-Authority-Condition

(Define-Frame Epml-Actor-Authority-Condition :Own-Slots ((Instance-Of Class) (Subclass-Of State-Of-Affairs) (Documentation "This defines a restricted subset of State-Of-Affairs, where the relationship is of type Epml-Actor-Authority")) :Axioms (<=> (Epml-Actor-Authority-Condition ?Soa) (Restricted-List-Of-Relsents ?Soa (Quote (Epml-Actor-Authority))))) 


;;; Epml-Actor-Authority-Constraint

(Define-Frame Epml-Actor-Authority-Constraint :Own-Slots ((Instance-Of Class) (Subclass-Of Epml-Pre-Condition) (Documentation "The authority that an actor requires to execute 
an activity")) :Template-Slots ((State-Description (Slot-Value-Type Epml-Actor-Authority-Condition) (Slot-Cardinality 1)))) 


;;; Epml-Person

(Define-Frame Epml-Person :Own-Slots ((Arity 1) (Instance-Of Class) (Subclass-Of Epml-Actor) (Documentation "A human being"))) 


;;; Epml-Group-Members

(Define-Frame Epml-Group-Members :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range Epml-Person) (Domain Epml-Group) (Documentation "The Epml-Person's in a Epml-Group"))) 


;;; Epml-Specified-Pre-Condition

(Define-Frame Epml-Specified-Pre-Condition :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range Epml-Pre-Condition) (Domain Epml-Activity) (Documentation "A relationship between an activity and a
input-constraint whereby the constraint needs to be satified in order
for the activity to start."))) 


;;; Epml-Activity-Interval

(Define-Frame Epml-Activity-Interval :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range Time-Range) (Domain Epml-Activity) (Documentation "A relationship between an activity and a time-range
whereby the activity takes place during the time interval."))) 


;;; Epml-Output-Resource-Failure-Status-Constraint

(Define-Frame Epml-Output-Resource-Failure-Status-Constraint :Own-Slots ((Instance-Of Class) (Subclass-Of Epml-Effect) (Documentation "The state value that a resource will have if the
activity fails to complete successfully")) :Template-Slots ((State-Description (Slot-Value-Type Epml-Resource-Condition) (Slot-Cardinality 1)))) 


;;; Epml-Input-Activity-Status-Constraint

(Define-Frame Epml-Input-Activity-Status-Constraint :Own-Slots ((Instance-Of Class) (Subclass-Of Epml-Pre-Condition) (Documentation "The necessary state values that a preceding activity
must have for an activity to be started")) :Template-Slots ((State-Description (Slot-Value-Type Epml-Activity-Condition) (Slot-Cardinality 1)))) 


;;; Epml-Tool

(Define-Frame Epml-Tool :Own-Slots ((Arity 1) (Instance-Of Class) (Subclass-Of Epml-Resource) (Documentation "An abstract class to define types of tools which can
carry out tasks, e.g. word-processor, or instances of tools, e.g.
emacs."))) 


;;; Epml-Actor

(Define-Frame Epml-Actor :Own-Slots ((Instance-Of Class) (Subclass-Of Actor) (Documentation "More used as an abstract class. An actor here can be
a person, group, organisation or software tool")) :Template-Slots ((Epml-Actor-Name (Slot-Value-Type String) (Slot-Cardinality 1)) (Epml-Actor-Status (Slot-Value-Type Epml-Actor-State) (Slot-Cardinality 1)) (Epml-Activities-Performed (Slot-Value-Type Epml-Activity) (Minimum-Slot-Cardinality 0)) (Epml-Activities-Owned (Slot-Value-Type Epml-Activity) (Minimum-Slot-Cardinality 0)) (Epml-Actor-Capability (Slot-Value-Type Epml-Activity) (Minimum-Slot-Cardinality 0)) (Epml-Actor-Authority (Slot-Value-Type Epml-Activity) (Minimum-Slot-Cardinality 0)))) 


;;; Epml-Active

(Define-Instance Epml-Active (Epml-Activity-State) "Specifies that the activity is active") 


;;; Epml-Specified-Effect

(Define-Frame Epml-Specified-Effect :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range Epml-Effect) (Domain Epml-Activity) (Documentation "A relationship between an activity and a
output-constraint whereby the constraint is brought about when the
activity has finished."))) 


;;; Epml-Activity-Name

(Define-Frame Epml-Activity-Name :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range String) (Domain Epml-Activity) (Documentation "The name of an activity."))) 


;;; Epml-Resource-Name

(Define-Frame Epml-Resource-Name :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range String) (Domain Epml-Resource) (Documentation "The name of a resource."))) 


;;; Epml-Activity-Condition

(Define-Frame Epml-Activity-Condition :Own-Slots ((Instance-Of Class) (Subclass-Of State-Of-Affairs) (Documentation "This defines a restricted subset of State-Of-Affairs, where the relationship is of type Epml-Activity-Status")) :Axioms (<=> (Epml-Activity-Condition ?Soa) (Restricted-List-Of-Relsents ?Soa (Quote (Epml-Activity-Status))))) 


;;; Epml-Output-Resource-Success-Status-Constraint

(Define-Frame Epml-Output-Resource-Success-Status-Constraint :Own-Slots ((Instance-Of Class) (Subclass-Of Epml-Effect) (Documentation "The state value that a resource will have if the activity
has been completed successfully")) :Template-Slots ((State-Description (Slot-Value-Type Epml-Resource-Condition) (Slot-Cardinality 1)))) 


;;; Epml-Effect

(Define-Frame Epml-Effect :Own-Slots ((Instance-Of Class) (Subclass-Of Effect) (Exhaustive-Subclass-Partition :Value (Setof Epml-Output-Activity-Status-Constraint Epml-Output-Resource-Success-Status-Constraint Epml-Output-Resource-Failure-Status-Constraint)) (Documentation "The Effect in a Specified-Effect 
relationship with some Activity"))) 


;;; Epml-Actor-Name

(Define-Frame Epml-Actor-Name :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range String) (Domain Epml-Actor) (Documentation "The name of an actor."))) 


;;; Epml-Activities-Owned

(Define-Frame Epml-Activities-Owned :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range Epml-Activity) (Domain Epml-Actor) (Documentation "A relationship between an Epml-Actor and a
Epml-Activity whereby the Epml-Actor owns the Epml-Activity"))) 


;;; Epml-No-Status

(Define-Instance Epml-No-Status (Epml-Activity-State Epml-Actor-State Epml-Resource-State) "Specifies that the status of an entity is not set") 


;;; Epml-Actor-Status

(Define-Frame Epml-Actor-Status :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range Epml-Actor-State) (Domain Epml-Actor) (Documentation "The status of an actor."))) 


;;; Epml-Activity-State

(Define-Frame Epml-Activity-State :Own-Slots ((Arity 1) (Instance-Of Class) (Subclass-Of Misc-Spec-Detail) (Documentation "A specification of the state of an Epml-Activity"))) 


;;; Epml-Activity-Status

(Define-Frame Epml-Activity-Status :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range Epml-Activity-State) (Domain Epml-Activity) (Documentation "The status of an activity."))) 


;;; Epml-Activity-Component

(Define-Frame Epml-Activity-Component :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range Epml-Activity) (Domain Epml-Activity) (Documentation "A relationship between an activity and another activity
whereby the latter activity is a sub-activuity of the former activity."))) 


;;; Epml-Resource-Condition

(Define-Frame Epml-Resource-Condition :Own-Slots ((Instance-Of Class) (Subclass-Of State-Of-Affairs) (Documentation "This defines a restricted subset of State-Of-Affairs, where the relationship is of type Epml-Resource-Status")) :Axioms (<=> (Epml-Resource-Condition ?Soa) (Restricted-List-Of-Relsents ?Soa (Quote (Epml-Resource-Status))))) 


;;; Epml-Activity-Predecessor

(Define-Frame Epml-Activity-Predecessor :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range Epml-Activity) (Domain Epml-Activity) (Documentation "An Activity is a predecsessor of another activity if
the activity begins after the predecessor activity completes and no
other activities occur between them."))) 


;;; Epml-Activities-Performed

(Define-Frame Epml-Activities-Performed :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range Epml-Activity) (Domain Epml-Actor) (Documentation "A relationship between an Epml-Actor and a
Epml-Activity whereby the Epml-Actor performs the Epml-Activity"))) 


;;; Epml-Resource-Location

(Define-Frame Epml-Resource-Location :Own-Slots ((Arity 2) (Instance-Of Binary-Relation Relation) (Range String) (Domain Epml-Resource) (Documentation "The location of the resource.")))