DAML-S

Process.daml

<?xml version='1.0' encoding='ISO-8859-1'?>
<rdf:RDF
  xmlns:rdf ="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
  xmlns:xsd ="http://www.w3.org/2000/10/XMLSchema#"
  xmlns:daml="http://www.daml.org/2001/03/daml+oil#"
  xmlns:service = "http://www.daml.org/services/daml-s/2001/10/Service#"
  xmlns      = "http://www.daml.org/services/daml-s/2001/10/Process#"
>

<daml:Ontology rdf:about="">
  <daml:versionInfo>
    $Id: Process.daml,v 1.17 2002/03/15 05:18:48 martin Exp $
  </daml:versionInfo>
  <rdfs:comment>
    Upper-level DAML ontology for Processes.
    Part of the DAML-S effort; see http://www.daml.org/services/.
  </rdfs:comment>
  <daml:imports rdf:resource="http://www.daml.org/2001/03/daml+oil"/>
  <daml:imports rdf:resource="http://www.ai.sri.com/daml/ontologies/sri-basic/1-0/Time.daml"/>
  <daml:imports rdf:resource="http://www.daml.org/services/daml-s/2001/10/Service.daml"/>
</daml:Ontology>

<!--######################################################
    Preliminaries
    ######################################################-->

<daml:Class rdf:ID="Condition">
  <rdfs:comment>
    This is a "place-holder" for now, which awaits further work from
    the DAML/OIL community.  An instance of Condition is a logical
    formula that evaluates to true or false.  Eventually we expect
    this to be defined elsewhere, as part of a DAML+OIL extension allowing
    for logical expressions.
  </rdfs:comment>
</daml:Class>

<daml:Class rdf:ID="ProcessClass">
  <rdfs:comment>
    This is the power set of Process (defined below); that is, the set
    of all subsets of Process.  This class is needed as the range
    of certain properties.  It's placed in "preliminaries" because of
    the expectation that a better way of declaring these ranges may be
    developed.
  </rdfs:comment>
  <rdfs:subClassOf rdf:resource="http://www.daml.org/2001/03/daml+oil#Class"/> 
</daml:Class>

<!--######################################################
    Connections to upper level Service ontology 
    ######################################################-->

<daml:Class rdf:ID="ProcessModel">
  <rdfs:comment>
    A ServiceModel describes how a Service works, and
    a ProcessModel is a type of ServiceModel (the only
    type being defined for DAML-S).
    See also the introductory comments to Service.daml.  
  </rdfs:comment>
  <rdfs:subClassOf rdf:resource="http://www.daml.org/services/daml-s/2001/10/Service#ServiceModel"/> 
</daml:Class>

<daml:ObjectProperty rdf:ID="hasProcess">
  <rdfs:comment>
    It is important to understand that DAML-S conceptualizes a specific process
    as a *class*, each of whose instances is a particular use/invocation of the
    process.  Thus, each specific process (such as BuyBook in Congo.daml) is
    a *subclass*, rather than an instance, of Process.  This is why the range
    of hasProcess is specified as ProcessClass (which is the class of
    all subclasses of Process).
    In the case of a composite process, indicates the top-level process class.
  </rdfs:comment>
  <rdfs:domain rdf:resource="#ProcessModel"/>
  <rdfs:range rdf:resource="#ProcessClass"/>
</daml:ObjectProperty>

<daml:Class rdf:ID="ProcessControlModel">
  <rdfs:comment>
    A ProcessControlModel is used to monitor and control execution of 
    a Process. This is just a "stub" for now; will be developed further
    in future releases of DAML-S.
  </rdfs:comment>
</daml:Class>

<daml:ObjectProperty rdf:ID="hasControlModel">
  <rdfs:domain rdf:resource="#ProcessModel"/>
  <rdfs:range rdf:resource="#ProcessControlModel"/>
</daml:ObjectProperty>

<daml:Class rdf:about="#ProcessModel">
  <rdfs:comment>
    A ProcessModel can have at most one Process and one ProcessControlModel.
  </rdfs:comment>
  <rdfs:subClassOf>
    <daml:Restriction daml:maxCardinality="1">
      <daml:onProperty rdf:resource="#hasProcess"/>
    </daml:Restriction>
  </rdfs:subClassOf>
  <rdfs:subClassOf>
    <daml:Restriction daml:maxCardinality="1">
      <daml:onProperty rdf:resource="#hasControlModel"/>
    </daml:Restriction>
  </rdfs:subClassOf>
</daml:Class>

<!--######################################################
    Processes
    ######################################################-->

<daml:Class rdf:ID="Process">
  <rdfs:comment> The most general class of processes </rdfs:comment>
  <daml:unionOf rdf:parseType="daml:collection">
    <daml:Class rdf:about="#AtomicProcess"/>
    <daml:Class rdf:about="#SimpleProcess"/>
    <daml:Class rdf:about="#CompositeProcess"/>
  </daml:unionOf>
</daml:Class>

<!--

Processes can have a name, parameters, preconditions, and
(conditional) effects.  Input, (conditional) output, and participant
are subproperties of parameter. Each input, output, parameter,
precondition or effect is a property of process, left unrestricted at
this level (it ranges over "Thing"). The basic attributes are similar
to the PDDL definition of events with the addition of input, output
and participant attributes.  

Processes can also be at an instant (atTime) or during an interval
(during).

-->

<daml:Property rdf:ID="name">
  <rdfs:domain rdf:resource="#Process"/>
  <rdfs:range rdf:resource="http://www.w3.org/2000/01/rdf-schema#Literal"/>
</daml:Property>

<daml:Class rdf:about="#Process">
  <rdfs:comment>
    A Process can have at most one name, but names need not be unique.
  </rdfs:comment>
  <rdfs:subClassOf>
    <daml:Restriction daml:maxCardinality="1">
      <daml:onProperty rdf:resource="#name"/>
    </daml:Restriction>
  </rdfs:subClassOf>
</daml:Class>

<!--
Precondition is a property of Process. The top level ontology
doesn't restrict them at all. A precondition can be any kind of daml
object (Thing).  Specific processes will specialize this property by
restricting the range appropriately using subPropertyOf; such as knowledge
Preconditions (agent knows credit card number) or world Precondition
(baud rate > 56Kb) 
-->

<daml:Property rdf:ID="precondition">  
  <rdfs:domain rdf:resource="#Process"/>
  <rdfs:range  rdf:resource="http://www.daml.org/2001/03/daml+oil#Thing"/>
</daml:Property>

<!--
Parameters are properties of processes. The top level ontology
doesn't restrict them at all. A parameter can be any kind of daml
object (Thing).  Specific processes will specialize this property by
restricting the range appropriately using subPropertyOf; such as the
credit card number sub-property of a buying event would be restricted
to have a range of type integer.  
-->

<daml:Property rdf:ID="parameter">
  <rdfs:domain rdf:resource="#Process"/>
  <rdfs:range  rdf:resource="http://www.daml.org/2001/03/daml+oil#Thing"/>
</daml:Property>

<!-- Effect is a property of process. The top level ontology doesn't
restrict them at all. An effect has the range ConditionalEffect.
Processes will have conditional effects.  For example, if the book is
in stock, it will be purchased after executing the buy-book process.
In the trivial case, the condition is "true" and the effect
unconditionally holds.
 -->

<daml:ObjectProperty rdf:ID="effect">
<rdfs:domain rdf:resource="#Process"/>
<rdfs:range  rdf:resource="#ConditionalEffect"/>
</daml:ObjectProperty>

<daml:Class rdf:ID="ConditionalEffect">
  <daml:subClassOf rdf:resource="http://www.daml.org/2001/03/daml+oil#Thing"/>
</daml:Class>

<!-- ConditionalEffect is a thing that consists of a condition, and an
effect thing.  It has two properties, the condtion (ceCondition) of
the conditional effect, and the effect (ceEffect) of the conditional
effect.  In the buy-book example ceCondition would be "inStock(book)"
and the ceEffect would be "purchased(book)".
 -->

<daml:Property rdf:ID="ceCondition">
 <rdfs:comment> The condition of a conditional effect. </rdfs:comment>
  <rdfs:domain rdf:resource="#ConditionalEffect"/>
  <rdfs:range rdf:resource="#Condition"/>
</daml:Property>

<daml:Property rdf:ID="ceEffect">
  <rdfs:domain rdf:resource="#ConditionalEffect"/>
  <rdfs:range rdf:resource="http://www.daml.org/2001/03/daml+oil#Thing"/>
</daml:Property>

<!-- We provide three common subtypes of parameters in the top level
ontology.  The types are input, conditionalOutput, and participant.  -->

<!-- An input is a type of parameter and is a property of
a process. The top level ontology doesn't restrict them at all. An input
can be any kind of daml object (Thing).  Specific processes will
specialize this property by restricting the range appropriately; such
as required inputs, derivable inputs, etc.
 -->

<daml:Property rdf:ID="input"> 
  <rdfs:subPropertyOf rdf:resource="#parameter"/> 
  <daml:range rdf:resource="http://www.daml.org/2001/03/daml+oil#Thing"/>
</daml:Property>

<!-- An output is a type of parameter and is a property of a
process. The top level ontology doesn't restrict them at all.  An
output can be any kind of daml object (Thing).  Each output may
(optionally) be associated with a Condition.

-->

<daml:Property rdf:ID="output">
  <rdfs:subPropertyOf rdf:resource="#parameter"/> 
  <rdfs:range rdf:resource="#ConditionalOutput"/>
</daml:Property>

<!-- ConditionalOutput is a thing that consists of a condition, and an
ouput thing. -->

<daml:Class rdf:ID="ConditionalOutput">
  <daml:subClassOf rdf:resource="http://www.daml.org/2001/03/daml+oil#Thing"/>
</daml:Class>

<daml:Property rdf:ID="coCondition">
 <rdfs:comment> The condition of a conditional output </rdfs:comment>
  <rdfs:domain rdf:resource="#ConditionalOutput"/>
  <rdfs:range rdf:resource="#Condition"/>
</daml:Property>

<daml:Property rdf:ID="coOutput">
  <rdfs:domain rdf:resource="#ConditionalOutput"/>
  <rdfs:range rdf:resource="http://www.daml.org/2001/03/daml+oil#Thing"/>
</daml:Property>


<!-- A participant is a type of parameter and is a property
of a process. The top level ontology doesn't restrict them at all. A
participant can be any kind of daml object (Thing).  Specific processes
will specialize this property by restricting the range to types of
agents, objects, entities, etc.  -->

<daml:Property rdf:ID="participant">  
  <rdfs:subPropertyOf rdf:resource="#parameter"/>
</daml:Property>

<!--- and other stuff....->

</rdf:RDF>







José M. Vidal .

10 of 26