Title:	Contract Related Agents
Date:	July 19, 2006 (Wednesday)
Time:	2:30 p.m. - 3:30 p.m.
Venue:	Room 121, 1/F, Ho Sin-hang Engineering Building, The Chinese University of Hong Kong, Shatin, N.T.
Speaker:	Professor Keith Clark Professor of Computational Logic Imperial College London United Kingdom

ABSTRACT:

We describe a multi-threaded declarative agent architecture in which an agent's relationships to other agent's are defined by a set of formal contracts held inside the agent. Some of these contracts determine services that the agent provides, others are outsourcing contracts for services other agents provide for it.

The contracts are declaratively formalised as event calculus rules. At any time point the state of a contractual relationship is determined by the contract rules and the events that have previously happened pertinent to the contract. An event E pertinent to a contract is notified by an agent Ag to all other parties to the contract via a dedicated contract channel. The channel authenticates the identity of Ag and forwards the tuple (Ag,E,T), T being the time the channel received the notification, to the other agents. In this way all the agents see the event as occurring at the same time T and know its source.

The contracts specify which agent or device are allowed to notify which events (for example a task request event or a task completion event) - hence the importance of the channel authentication of the notifier. They also specify conditions under which particular events initiate or terminate an obligation for one of the parties to the contract. Initiated obligations may have deadlines by which they must be discharged. A contract may also specify conditions under which an agent is considered to have violated the contract with respect to some obligation. A log of all the event tuples forwarded by the channel, together with the contract event calculus rules, can be used by an outside party to check for conformance with the contract - for example, to check if there has been any violation.

For each active contract an agent has a thread handling the event notifications for that contract. Any event that initiates an obligation causes an obligation notification to be sent to the agent's obligation handling thread. This tries to find and execute a plan to discharge the obligation in a timely fashion. Such a plan may in turn query the agent's other contracts to determine if, and if so when, a request event notified by the agent, to perform some sub-task of the plan, will result in an obligation on another agent to do the sub-task. Such a request can be used by the agent to outsource the sub-task.

For concreteness we sketch how the agent architecture might be implemented in the multi-threaded OO logic programming language QuP++, an extension of Qu-Prolog. We also give the rules for a single agent contract for a patrol robot, and the rules for multi-task service contract between a pair of agents in which tasks have maximum completion times and payments related to execution time.

BIOGRAPHY:

Keith Clark has been Professor of Computational Logic at Imperial College London since 1987. His main current research is symbolic programming languages, particularly logic based languages, and their use for rational agent applications and cognitive robotics.

Enquiries: Miss Temmy So at tel 2609 8444

For more information, please refer to http://www.cse.cuhk.edu.hk/seminar