COBRA-ONT v0.4 Tutorial 3
--------------------------

The following examples show how COBRA-ONT can be used to define
role/action template and to represent knowledge about the intional
actions of an agent and the doable actions that an agent undertakes.

The namespace shorthands are defined as the following:

role  <=> http://daml.umbc.edu/ontologies/cobra/0.4/role#
alit  <=> http://daml.umbc.edu/ontologies/cobra/0.4/adjustlighting#
ldpt  <=> http://daml.umbc.edu/ontologies/cobra/0.4/loadpresentation#
bkrm  <=> http://daml.umbc.edu/ontologies/cobra/0.4/bookroom#
agt   <=> http://daml.umbc.edu/ontologies/cobra/0.4/agent#
tme   <=> http://daml.umbc.edu/ontologies/cobra/0.4/time-basic#
mto   <=> http://daml.umbc.edu/ontologies/cobra/0.4/meeting#

---
Example 1. To associate actions with an agent's role, we define
role/action templates. Using these templates, a reasoning agent can
infer the type of actions that a user may intend to perform based on
its knowledge about the user's role. Using the inferred knowledge,
the agent may attempt to provide relavent services to the user (e.g.,
knowing the speaker intends to load presentation slides, the agent
does so when the speaker enters the room)

<role:RoleDef rdf:ID="http://cobra.umbc.edu/roleDef/A001">
    <role:roleType rdf:resource="&role;speaker"/>
    <role:intendsTo rdf:resource="&alit;adjustLighting"/>
    <role:intendsTo rdf:resource="&ldpt;loadPresentation"/>
</role:RoleDef>

<role:RoleDef rdf:ID="http://cobra.umbc.edu/roleDef/A002">
    <role:roleType rdf:resource="&role;host"/>
    <role:intendsTo rdf:resource="&bkrm;bookRoom"/>
</role:RoleDef>

<role:RoleDef rdf:ID="http://cobra.umbc.edu/roleDef/A003">
    <role:roleType rdf:resource="&role;audience"/>

    <!-- The following action types are not currently defined
         in the ontology. They are referred here for
         demonstration purpose. -->
    <role:intendsTo rdf:resource="&acqp;acquirePresentationSlides"/>
    <role:intendsTo rdf:resource="&exct;exchangeContact"/>
</role:RoleDef>

<role:RoleDef rdf:ID="http://cobra.umbc.edu/roleDef/A004">
    <role:roleType rdf:resource="&role;visitor"/>

    <!-- The following action types are not currently defined
         in the ontology. They are referred here for the
         demonstration purpose. -->
    <role:intendsTo rdf:resource="&ctaxi;callTaxi"/>
    <role:intendsTo rdf:resource="&maps;findMapDirection"/>
</role:RoleDef>
---
Example 2. Different users in a meeting may play different
roles. Their roles can dictate the inference of a reasoning agent to
determine their intentional actions (using the pre-defined role/action
templates). The following shows how to represent an agent's knowledge
about the role of a user in a meeting. This representation provides a
means for multiple agents to share knowledge about a user's role. 

NOTE: the "timeInterval" property of the class "Role" defines the
time interval between which the role of the user holds. This allows
multiple definitions of roles to be associated with a single user
for different meeting events. Both "startTime" & "endTime" are
defined in Tutorial2.txt. The "timeInterval" can be any time interval,
but it must be inside the range of "startTime" and "endTime".

<agt:Person rdf:about="http://umbc.edu/~hchen4">
    <agt:hasRole>
        <role:Role>
            <role:roleType rdf:resource="&role;speaker"/>

            <role:timeInterval>
                <tme:ProperInterval>
                    <tme:hasIntervalDescription>
		        <tme:IntervalDescription>
	    		    <tme:firstInstantDescription 
	        rdf:resource="http://ittalks.org/talk/09222003b/startTime"/>
			    <tme:secondInstantDescription 
	        rdf:resource="http://ittalks.org/talk/09222003b/endTime"/>
        	        </tme:IntervalDescription>
		    <tme:hasIntervalDescription>
                </tme:ProperInterval>
            </role:timeInterval>            
	    				    
	    <role:associatedWithMeeting 
	        rdf:resource="http://ittalks.org/talk/09222003b"/>

        </role:Role>
    </agt:hasRole>
</agt:Person>

<agt:Person rdf:about="http://umbc.edu/~fperic1">
    <agt:hasRole>
        <role:Role>
            <role:roleType rdf:resource="&role;host"/>
            <role:timeInterval>
                <tme:ProperInterval>
                    <tme:hasIntervalDescription>
		        <tme:IntervalDescription>
	    		    <tme:firstInstantDescription 
	        rdf:resource="http://ittalks.org/talk/09222003b/startTime"/>
			    <tme:secondInstantDescription 
	        rdf:resource="http://ittalks.org/talk/09222003b/endTime"/>
        	        </tme:IntervalDescription>
		    <tme:hasIntervalDescription>
                </tme:ProperInterval>
            </role:timeInterval>            

	    <role:associatedWithMeeting 
	        rdf:resource="http://ittalks.org/talk/09222003b"/>

        </role:Role>
    </agt:hasRole>
</agt:Person>

---
Example 3. Knowing the role of a user and the associated actions in
the role/actions template, a reasoning agent may infer the specific
actions that the user intends to perform. The inference result may
also include specific action parameters (e.g., for the
"loadpresentation" action, the action parameter includes a URL to the
PPT file that is to be loaded; for the "adjustlighting" action, the
action parameter includes the specific command to send the light
controller). 

<agt:Person rdf:about="http://umbc.edu/~hchen4">
    <agt:intends>
        <act:DoAction>
            <act:actor rdf:resource="http://umbc.edu/~hchen4"/>

            <act:action>
                <alit:AdjustLighting>
                    <alit:parameter rdf:resource="&alit;Dimmer"/>
                </alit:AdjustLighting>
            </act:action>

            <act:actDuring 
	        rdf:resource="[sometimes during the meeting]"/>
         </act:DoAction>
    </agt:intends>

    <agt:intends>
        <act:DoAction>
            <act:actor rdf:resource="http://umbc.edu/~hchen4"/>

            <act:action>
               <ldpt:LoadPresentation>
                   <ldpt:slideURI>
                       http://umbc.edu/~hchen4/ppt/intro2ct.ppt
                   </ldpt:slideURI>
   	
               <!-- myAgent should be notifed about the status of
   	         setting up the Power Point presentation slide -->
                   <ldpt:contact
	              rdf:resource="http://umbc.edu/~hchen4/myAgent"/>
               </ldpt:LoadPresentation>
            </act:action>

         <act:actBefore
	        rdf:resource="[sometimes before the lights are dimmed]"/>
        </act:DoAction>
    </agt:intends>

</agt:Person>

---
Example 4. Agents can do actions. Actions that are undertaken by a
person are called "doable actions". Each doable action has associated
temporal property, which allows reasoning agents to keep track of the
action history of a user.

<agt:Person rdf:about="http://umbc.edu/~hchen4">
    <agt:undertakes>
        <pmt:ParticipateMeeting>
            <pmt:meeting rdf:resource="http://ittalks.org/talk/09222003b"/>

            <tme:hasIntervalDescription>
		<tme:IntervalDescription>

	   	    <tme:firstInstantDescription 
	        rdf:resource="http://ittalks.org/talk/09222003b/startTime"/>

		    <tme:secondInstantDescription 
	        rdf:resource="http://ittalks.org/talk/09222003b/endTime"/>

        	</tme:IntervalDescription>
            <tme:hasIntervalDescription>               
        </pmt:ParticipateMeeting>
    </agt:undertakes>
</agt:Person>

NOTE: the temporal property of any doable action can be either a time
instant of a time interval.