On Managing Temporal Information for Handling Durative Actions in LPG

Newsletter of theEuropean Network

of Excellencein

AI Planning

Issue No.7

http://www.planet-noe.org

ISSN 1610-0204

The PLANET Newsletter 3

Issue No.7

EDITORIAL

Welcome to PLANET NEWS!

PLANET’s Industrial Information Daysare aimed atpromoting the transfer of Plannning and Schedulingtechnology. At these events, an international panelof speakers presents successful applications of plan-ning and scheduling to an industrial audience and dis-cusses promising future exploitation.The latest information days took place at the CharlesUniversity in Prague in May (for a report see RomanBartak’s article in the last issue) and at the Univer-sity of Ulm in June, respectively. In Prague, MichalPechoucek from the Gerstner Laboratory at the CzechTechnical University in Prague was one of the speak-ers. In the first section of this issue, you can find hisoverview on both theoretical achievements and prac-tical applications of the distributed planning technol-ogy in the Gerstner Laboratory. It focuses primarilyon the concept of social knowledge and acquaintancemodels and shows their potentials in planning appli-cations.

Another major event was theThird PLANET In-ternational Summer School on AI Planningheld inMadonna di Campiglio, Trento (Italy) in June. Likelast year’s school, the attending students were en-couraged to present their Ph.D. projects in a separateposter session. This session, which actually had tobe split up into two full sessions, was very success-ful and showed a variety of interesting aspects and

new approaches. A report on the school and severalextended abstracts of the poster presentations are in-cluded in this newsletter.

Joachim Hertzberg provides you on page 45 a de-tailed insight into the International Conference onAutomated Planning and Scheduling (ICAPS 2003)held in Trento in June. Information on the forthcom-ing ICAPS 2004 and an overview over the currentmembers of the network can be found in the final sec-tion.

We hope you enjoy reading thesePLANET News.

Susanne BiundoBernd Schattenberg

Editors:

Susanne Biundo Network Coordinator, Dept. ofArtificial Intelligence, University of Ulm, [email protected]

Bernd Schattenberg Network Assistant,Dept. of Artificial Intelligence, University of Ulm,[email protected].

de �

4 The PLANET Newsletter

Table of Contents

Editorial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .3

Industrial Information Day PragueM. Pechoucek: Agent Based Production Planning5

3rd PLANET Summer SchoolM. Carman, and M. Michalowski:3rd InternationalSummer School on AI Planning – A Student’s Per-spective. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10K. Halsey:Temporal Planning with a Non-TemporalPlanner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .13A. Mileo: Automated Reasoning with Policies andPreferencial Monitors. . . . . . . . . . . . . . . . . . . . . . . .19B. Innocenti, B. Lopez, and J. Salvi:Multi-AgentPlanning Architecture for Autonomous Robots. . 24

Y. Zemali: Optimal Heuristic Planning using SearchSpace Splitting. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .28A. Saetti, A. Gerevini, and I. Serina:Managing Tem-poral Information for Durative Actions inLPG . . 35C. Doniat:The PLANFORM - KATool. . . . . . . . . .41

ReportsJ. Hertzberg:The ICAPS 2003 Conference. . . . . .45

AnnouncementsICAPS 2004.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .47

InformationThe Members of PLANET. . . . . . . . . . . . . . . . . . . .48

�



REPORT

Agent Based Production Planning

Author: M. Pechoucek

Introduction

Agent based systems are collections of autonomouscomputational elements, independent programs(hereafter we will refer to these elements as agents)that perform collective behavior in order to meet ei-ther their individual goals (self interested agents) ora in-community shared goal (collaborative agents)[7], [5].They exchange information and knowledgein order to achieve desired instance of collaboration.Multi-agent decision making is not only processinginformation from various sources of diverse nature.Multi-agent systems allow its agents to act pro ac-tively: any agent is able to try to persuade the restof the community members to adopt the agent’s localgoal as their joint motivation and implement it. Ei-ther hierarchical, heterarchical or partially structuredcommunities of agents perform joint decision makingby means of communication, collaboration, negotia-tion, and responsibility delegation that are based onagents’ individual rationality and social intelligence.The field of distributed artificial intelligence andagent-based systems provides production planningand intelligent manufacturing systems in general withthree distinctive pieces of technology:

� architectures and design methodologyfor devel-opment of integrated enterprize resource plan-ning systems (there were several referential ar-chitecture developed, e.g. Prosa architecture,Holonic Manufacturing Systems,ProPlanT archi-tecture, etc.)

� technologies for iteroperability, agentification,and legacy systems integration (with a set of im-portant standard activities going on within FIPA,OPC, Semantic Web community, etc.)

� technologies fordistributed decision makingalgo-rithms and agent-based planning in particular

There were several different approaches how to im-plement planning and balanced resource allocation incomplex distributed systems (e.g. auctioning and ad-vanced methods of negotiation, parallel processing,reactive agents and stigmergic approach, intelligencebased interaction, etc).

Agent-based Planning

There are many advantages why the agent-based ap-proach to planning shall be adopted. Agent basedplanning offers very often high degree of reconfig-urability and flexibility as the same planning algo-rithms for particular agents can be used in many dif-ferent settings of the agent community. Agent-basedplanning also offers tractability and capability to ex-plain how the decision has been made (on the single-agent level). It is very convenient to use this approachin domains with natural distribution of physical ele-ments (e.g. logistics, flight control,. . . ) Using ad-vanced techniques of distributed artificial intelligenceplanning efficiency can be substantially improved.In principle, we have three fundamental approachesto agent-based planning:

� decomposition based planning:there is a tem-porary or permanent hierarchy of agents whereeach decomposes a task into subtasks and coor-dinates its completion. can be done via contract-net-protocols, subscriptions, etc.

� fully autonomous planning:all agents see theplanning problem and form their local plans. theseplans are later merged and conflicts are resolvedbyre-planning e.g. PGP Partial Global Plan-ning. agents share a common knowledge structure(blackboard) or there is a high-level coordinator(who resolves the conflicts) or agents interact viarather inefficient distributed techniques (negotia-tion, broadcast, rings, voting, etc.)

https://www.researchgate.net/publication/239665875_The_computation_complexity_of_propositional_strips?el=1_x_8&enrichId=rgreq-a0179853301e215269b1676089e12005-XXX&enrichSource=Y292ZXJQYWdlOzIyMTE1MzMwNjtBUzo5NzU2Mjg3NDg3NTkxN0AxNDAwMjcyMjEwNzgw


� backward chaining planning:a compromise be-tween (i) and (ii). the request backpropagets in themanufacturing flow. there is no command-and-control hierarchy and no central component, butagents negotiate via contract-net-protocols, sub-scriptions, etc.

Let us talk about the decomposition based planning –by far the most implemented approach in any agent-based planning application. An agent (or a commu-nity of agents) is supposed to find ateam-action planfor a task. Each task can be be either implementedby a single agent or it can be decomposed (and coor-dinated) within several agents. The team-action planis a distributed knowledge structure that representsagents individual commitments to their contributionto the in-community shared task. The team-actionplan consist of a collection of individual team-actionplans (non-decomposable commitment) and collec-tive team-action plan (agents commitment to coordi-nate). Consequently,an agent, when forming a teamaction plan, has to face two problems:

� how to decompose a task into subtask and

� whom to subcontract for cooperation,

Let us introduce and comment three decomposi-tion/subscription approaches to team action planning.

Contract Net Protocol

A stable and industry accepted approach to the co-ordination of agents’ joint activity is based on clearcut roles (even temporary) in the multi-agent commu-nity. Let us have acoordinator who is in charge ofproper task decomposition and subcontractingcon-tractors for implementing components of the tasks.A classical and industry accepted negotiation algo-rithm is contract-net-protocol[6].Any agent (will become a coordinator) can initiatethe contract net by requesting some contractors forspecific services. Each contractor carries out its owninternal reasoning and suggests a collaboration pro-posal. Upon receiving proposals for collaboration,

the coordinator carries out a computational processby which it selects the best possible collaborator(s)– cf. Fig. 1. The contract net protocol can be alsomulti-staged. For each single-staged CNP within acommunity of� agents, it is needed to send��messages in the worst case.

Figure 1: Contraction based on a Single-staged Con-tract Net Protocol

Such an approach requires substantial computationalresources and fails in complex communities. At thesame time many agents may not want to enter theCNP negotiation, as they wouldn’t wish to undertakethe risk of disclosing their private knowledge.Optimality of the Contract-net-protocol relies on thestrong assumption, that there is exactly one possibledecomposition of the original task, with many possi-ble allocation between the contractors. In this casethe coordinator initiates CNP to all possible subtasksand selects the best allocation.However in real cases there are several (usuallymany) possible ways how to decompose a task intosubtasks. The coordinator shall try them out one afteranother select the most optimal contract net. Giventhe possible high degree of agents flexibility to substi-tute each other, the space of all possible team-actionplans is enormous in real applications.Example 1: When planning a humanitarian reliefmission each provider can ship a different number ofresources to different places and at different times.As the humanitarian organizations are very similar,one can assume that anyone can virtually provideanything. Once there is a request for 200 land-minesexperts, each of say 50 providers can provide one up


https://www.researchgate.net/publication/220543399_The_Automatic_Inference_of_State_Invariants_in_TIM?el=1_x_8&enrichId=rgreq-a0179853301e215269b1676089e12005-XXX&enrichSource=Y292ZXJQYWdlOzIyMTE1MzMwNjtBUzo5NzU2Mjg3NDg3NTkxN0AxNDAwMjcyMjEwNzgw


to 50 experts at different times. The number of possi-ble decompositions and contractions in this realisticscenario is really enormous.

Subscription Based Contraction (SBC)

In order to address these issues, we suggest to usean alternative approach that is based on exploitationof the agents’ social knowledge (inspired by [1]). Acoalition coordinator subscribes (by sending asub-scribe-type of message) the potential collaboratorsfor specific services for all possible tasks the con-tractor may participate in the future. The contractorreplies with the appropriate parts of the hypotheticalteam-action plans. Upon a change in either of theproperties of each of the service , the contractor shallprovide the coordinator with an update in the form ofanotherinform-type of message. When the coordi-nator triggers the coalition formation phase, it parsesthe prepared service offers and selects the best col-laborator(s) without any further negotiation. The co-ordinator sends a request, the collaborator updates itsresources and confirms the contract. Any change incollaborator resources is advertised to all coordina-tors which subscribed the collaborator (cf. Fig. 2).

Figure 2: Contraction based on Acquaintance Modelexploitation

If there is a single event in the community� that af-fects all the agents�� and all the agents aremutually subscribed, then in the worst case there is�� messages required for the social knowl-edge maintenance on this event. However, this israrely the case. Agents never subscribe all eachother(we could easily use a central communicationcomponent instead).In order to make a good decomposition, the coordina-tor needs to have a full model of the services (when,where, for how much, etc.) that the contractors mayprovide. This is a difficult requirement from threereasons:

� complexity– as emphasized before, it is hard (orpractically impossible) to enumerate all variationsof deliveries that an agent can make,

� confidentiality– very often, the collaborators arehappy to work together but they do not want toshare the complete information about their possi-ble resources – this is confidential in many practi-cal applications (e.g. supply chain management),and

� concept– if there is an agent that has got a com-plete model of the other agents and this agent isin charge of decision making, we do not need dis-tributed (agent-like) solution and all the computa-tional process may run in the central agent,

Collaborative Subscription BasedContraction (CSBC)

Yet another technologically improvement is neededin order to address the issues listed above. Let us as-sume that the coordinator does not have the completesocial model of the contractors. In order to achievereasonable level of rationality in short amount of timethe agents (both coordinator and the contractor) mustwork together on top of the imprecise and incompleteinformation. The role of the agents will be as follows:

� contractor: will be continually watching its re-sources and compute an approximative model(e.g. linear approximation) of its availability.


� coordinator: will be in charge of the fusing theapproximative models provided by the contractorsand using this information for suggesting the rightdecomposition.

The agents collective behavior is straightforward.The contractor subscribes the contractors for an ap-proximative description of their resource availabil-ity. Once the coordinator needs to suggest a close-to-optimal decomposition and requires a resources, itparsers its acquaintance model (e.g. simple summa-tion of the lienal functions in the case of the linearapproximation). The request for calculated amountof resources per each contractor is subject of a subse-quent collaboration proposal. The coordinator eitherlikes the proposal (and replies with an agree speech-act message) or finds the proposal too different fromwhat it can actually do. In the latter case the contrac-tor replies with arefuse speech-act message andprovides a counterproposal. The coordinator uses theresource values in the counterproposal for fixing thesocial knowledge it keeps about the respective con-tractor (e.g. replacing the linear approximation withthe pairwise linear approximation).The form of the social knowledge approximation is akey in designing a successful collaborative subscrip-tion based contraction mechanism. Naturally, a scalarnumber representing the contractor resource (or evena set of resources) is very convenient to maintain andexploit. Agent’s response is expected to be very fast.However, the suggest decomposition is expected tobe very imprecise and the contraction lifestyle to con-tain many interactions. A more precise option is torepresent the resource availability by a function, thatis easy to be computed –linear function. This isstill very easy to be handled, while it provides muchhigher reliability. One would hardly recommend tousematricesfor representing agents resources, dueto high computational requirements for its manipula-tion and maintenance. In extreme cases we can usea complete enumeration of all combination of agentsresource availability. This form of social knowledgewill provide the coordinator with utterly exact infor-mation. However, for the reasons given in the SBC

section, we disregard this option.

Applications

In the Gerstner Laboratory at the Czech TechnicalUniversity in Prague we have been investigating theseconcepts for several years now. Various researchprojects and research efforts resulted in two main pi-lot prototypes of planning systems.ExPlanTech. The ProPlanT architecture has beenimplemented in JADE,an agent development plat-form [3]. The originated system – ExPlanTech –has been deployed successfully in the Czech man-ufacturing a enterpriser, ModelarnaLiaz, sro. anda Greek provider of packaging, Chatzapoulos SA.Together with GEDAS, we are designing a similarsystem for a new Skoda/VW engine manufacturingplant. Currently, the ExPlanTech multi-agent sys-tem has been extended beyond the scope of classicalintra-enterpriseproduction planning. Various suppli-ers and customer may integrate their agents in orderinfluence the production process in the most optimalway (extra-enterpriseproduction planning).CPlanT.Based on SBC and CSBC, we have devel-oped a prototype system for planning war avoidanceoperations such as peace-keeping, peace-enforcing,non-combatant evacuation or disaster relief opera-tions [4]. Unlike in classical war operations, wherethe technology of decision making is strictly hierar-chical, operations other than war (OOTW) are verylikely to be based on cooperation of a number of dif-ferent, quasi-volunteered, vaguely organized groupsof people, non-governmental organizations (NGO’s),institutions providing humanitarian aid, but also armytroops and official governmental initiatives.

Bibliography

[1] Cao, W., Bian, C.-G., and Hartvigsen, G. (1997)Achieving Efficient Cooperation in a Multi-Agent System: The Twin-Base Modelling. In:Co-operative Information Agents(Kandzia, P.,Klusch, M. eds.), LNAI No. 1202, Springer Ver-lag, Heidelberg, 210-221.


https://www.researchgate.net/publication/220604717_Heuristic_Search_Planner_20?el=1_x_8&enrichId=rgreq-a0179853301e215269b1676089e12005-XXX&enrichSource=Y292ZXJQYWdlOzIyMTE1MzMwNjtBUzo5NzU2Mjg3NDg3NTkxN0AxNDAwMjcyMjEwNzgw


[2] Marik, V., Pechoucek, M., Stepankova, O.,(2001) “Social Knowledge in Multi-Agent Sys-tems”, In (M. Luck et. al, eds.)Multi-Agent Sys-tems and Applications, LNAI 2086, Springer-Verlag, Heidelberg, 2001, pp.211-245.

[3] Pechoucek, M., Riha, A., Vokrnek, J., Marik, V.,Prazma, V., ExPlanTech: applying multi-agentsystems in production planning. In:Interna-tional Journal of Production Research.2002,vol. 40, no. 15, p. 3681-3692.

[4] Pechoucek, M., Marik, V., Barta, J.: AKnowledge-Based Approach to Coalition For-mation. In:IEEE Intelligent Systems. 2002, vol.17, no. 3, p. 17-25. ISSN 1094- 7167.

[5] Sandholm, T., Larson, K., Andersson, M., She-hory, O., and Tohme, F. (1999). Coalition Struc-

ture Generation with Worst Case Guarantees.Artificial Intelligence, 111(1- 2), 209-238.

[6] Smith, R., (1980) The contract net protocol:High-level communication and control in dis-tributed problem solver.IEEE Transactions onComputers, 29(12):1104-1113

[7] Wooldridge, M., (2000)Reasoning about Ratio-nal Agents, The MIT Press, Cambridge, MA.

Author Information

Michal Pechoucek Gerstner Laboratory, CzechTechnical University in Prague, Technicka 2, 166 27,Prague 6, Czech [email protected] �


REPORT

3rd International Summer School on AI Planning – A Student’sPerspective

Author: M. Carman, and M. Michalowski

The thirdPLANET sponsored summer school on AIPlanning was held from June 15 to 19 in the weekfollowing the International Conference on Planningand Scheduling. The location was the alpine town ofMadonna di Campiglio, in the heart of Italy’s splen-did Dolomite mountain ranges. The beautiful and re-mote setting enabled the participants (both lecturersand students) to relax and concentrate on the themeof the summer school namely, the state-of-the-art inartificial intelligence planning systems.

Figure 1: Jörg Hoffmann during a lecture.

Sunday morning, after a good sleep and a more thanample breakfast, Richard Korf from the University ofCalifornia, lead the charge with the first of two lec-tures on Search Techniques. In the first lecture he in-troduced planning as state space search problem, anddiscussed breadth and depth first search strategies,searching graphs with cycles, and Frontier search.Richard’s engaging and humor-filled lecturing stylemade the lecture highly enjoyable, as did his abil-ity to explain clearly the material and answer pre-cisely the questions posed. Following a short cof-fee break, which allowed for yet more discussions,Richard returned to discuss A* and its derivatives

(such as IDA*, IDBnB, etc.), and more generally theuse of heuristics in search, before concluding with adiscussion of the use of pattern databases for comput-ing more powerful heuristics.

After lunch, the technical program recommencedwith a peek into the world outside our planet. KannaRajan from NASA Ames Research Centre introducedus to the space application area for planning andscheduling technology. He first discussed the impor-tance of the space domain, and gave motivations forplanning research in this domain, including the au-tomation of complex and repetitive tasks with con-textual dependencies, the abstraction of activities thatcan be conditionally executed, and the optimized useof resources (such as fuel, water, battery power). Hethen discussed some sample missions, where tasks in-clude environmental map building, tracking and nav-igation.

The second day of lectures was kicked off by JörgHoffmann from the University of Freiburg. Jörggave a full speed (or should we say “Fast Forward”?)tour of the latest in heuristic and graph-plan basedplanning techniques. Having first disregarded ev-erything occurring prior to 1995 in planning as pre-historic, he described the difference between plan-ners solving the bounded plan-length plan discov-ery problem (find a plan of length k, i.e. graphplanapproaches), and those solving the unbounded prob-lem (i.e. heuristic search approaches). The first lec-ture was then devoted to graphplan-like approachesin terms of reachability analysis, regression search,and non-directional search (SAT). The second lecturewas devoted to greedy (heuristic-based) approachesin terms of ignoring delete lists, forward/backward-chaining versus local search, and the analysis of dif-ferent planning domains in terms of local searchtopologies.



The afternoon was again filled with space explo-ration. This time Kanna gave an overview of pastand current planning and scheduling applications, in-cluding scheduling systems for earth uplink visibilitywindows, data management softbots, and flight plan-ning for earth observation airplanes.After Kanna’s talk came the first of the student postersessions. The large number of students wishing topresent posters meant that the school poster sessionwas split in two to give students more visibility. Thefirst session was very well attended with not only a lotof interaction between lecturers and students, but alsobetween the students themselves. The quality of theposter presentations was impressive as was the rangeof different topics being addressed.Wednesday morning, after a good night of dancing tosome live music in the bar, was devoted to control-intensive planning techniques. And who better to in-troduce this topic than an international planning com-petition winning applier of such techniques, FahiemBacchus from the University of Toronto? The lec-ture started with a discussion of the motivation forcontrol intensive planning. Then the main paradigmfor adding control knowledge – encoding knowledgeas to desirable and non-desirable state sequences –was introduced. LTL was described as a language fordescribing control knowledge over state sequences.By viewing the planning state space as a relationaldatabase, against which first-order queries can beposed, the efficient exploitation of control knowledgecan be performed, by materializing some views andaugmenting some action preconditions. The lecturesfinished with a discussion of an alternative paradigmfor control intensive planning, that of “lifted decisionmaking”, which is best achieved through the manualaddition of special “decision actions” to the domain.That afternoon, the topic was planning and schedul-ing with time and resource constraints by an ex-perienced practitioner in the field, Claude Le Papefrom ILOG. Claude started his lectures by givingan overview of constraint programming techniques:constraint propagation, partial constraint propaga-tion, as well as incrementality and locality principles.The theory was interleaved with many examples to

ease understanding. He then moved on to talk aboutconstraint-based scheduling, involving the propaga-tion of temporal and resource constraints, and dis-cussed some example practical applications in thisarea. The last topic discussed was cooperative prob-lem solving, which included discussions of mixed in-teger programming, local search techniques, hybridapproaches along with problem decomposition tech-niques.

Figure 2: The Golf Hotel in Madonna di Campiglio,Italy

The next morning ominous weather forecasts saw thepostponement of the excursion to the last day of theschool, and Dan Weld from the University of Wash-ington proceeded with his lectures on planning forthe Web. The first part of his lectures was concernedwith planning for data integration, or more specifi-cally, with providing uniform access to disparate datasources, answering queries using views, and execut-ing in the face of uncertainty and latency. The secondpart of his lectures concerned planning for service in-tegration, including the invoking and composing ofweb services, querying and updating databases, andplanning with incomplete information.First up in the afternoon was Sven Koenig fromthe Georgia Institute of Technology, introducing thetopic of planning in robotics. Sven was extremelyenthusiastic when discussing his topic, inspiring theaudience to join the robotics planning community.In the first lecture he discussed robot architectures


and planning in general. He then moved on to robotnavigation, discussing domain discretization, greedymapping techniques for unknown domains, planningwith the free space assumption, the Lifelong PlanningA* algorithm, and the D* Lite algorithm.

Immediately following Sven’s presentation came aninvited “Mystery Talk” by David Smith from NASAAmes. The talk revolved around the future directionsfor planning research, and how the current state-of-the-art planning systems need to be extended in or-der to make them useful to NASA, i.e. to control arover (robot) on unmanned missions to Mars. Daviddescribed the six most important issues and ratedthem in terms of the difficulty to incorporate solutionsto them into the current planning technology. Thesix problems outlined were: exogenous conditions &events, over-subscription problems, uncertainty, ram-ifications, plan revision, and external reasoning.

A second poster session followed the talk, again withhigh attendance and much interest from all parties.The crowd moved straight from the poster sessiononto dinner, and most were then soon off to bed aftera long day of lectures.

The next morning we woke to see a beautiful bluesky, which was a good sign, as the highlight of thenon-technical school program, the school excursionwas programmed for that morning. The excursionwas a trip up in the beautiful Dolomite mountainssurrounding Madonna di Campiglio. Having walkedinto the centre of town, we were loaded onto a ca-ble car, specially organised to take us up to the topof the hill. At the top the view out over the moun-tains was breathtaking. We then proceeded on a walkthrough the mountain fields, which at the time werecovered with beautiful wild flowers in bloom. Hav-ing reached a summit refuge, some of the participants

returned with the cable car, while the more adventur-ous among us started out on the long but worthwhilewalk down the mountain. Adventures along the wayincluded a high-altitude Frisbee match, tree climbing,log throwing and some gazing at the impressive wa-terfalls found along the way.We returned, sun-burnt and weary after a long walk,but ready nonetheless for another enthusiastic lectureon planning and robotics by Sven Koenig. This timeSven turned his attention to optimal and greedy robotlocalization algorithms, as well as handling actuatorand sensor uncertainty in the POMDP framework.The next morning we parted ways, having mademany friends and learnt much regarding the state-of-the-art in AI planning systems. On behalf of the stu-dents who attended the summer school we would liketo thank PLANET for its generous sponsorship of theschool, and the school chairs Alessandro Cimatti andDaniel Borrajo for all of their work in making theevent such a success.

Author Information

Mark Carman Automated Reasoning SystemsDivision, ITC-irst, Univ. of Trento, [email protected]

Martin Michalowski Information Sciences Insti-tute, Univ. of Southern California, [email protected]

Further information can be found on the school’s website at

http://sra.itc.it/planet/summer-school-03/

�



ARTICLE

Temporal Planning with a Non-Temporal Planner

Author: K. Halsey

Introduction

This extended abstract looks at the work that I amcurrently undertaking in the field of temporal plan-ning. Temporal planning is the same problem as clas-sical planning but, whereas in classical planning allactions are considered to be instantaneous, in tempo-ral planning time is also modelled. One possible wayto achieve this is to introduce actions with duration.These durations can rely on the parameters of the ac-tion (e.g. a plane takes longer to fly the further the dis-tance between its departure and arrival cities), calledcomputed durations. Relaxing this one assumptioncomplicates the problem, since now a new metric isintroduced to judge plans by; it is no longer the planwith the fewest actions which could be seen as best,but that with the shortest total duration. Concurrencycan now be exploited within the plan, where two ormore actions can overlap and be executed simultane-ously. This relies on the capabilities of the executiveand, as described later, the expressiveness of the de-scription language. Concurrent actions must not in-terfere with each other; this is another challenge forthe planner. Temporal planning can be seen as themerging of classical planning and scheduling.

Whilst classical planning, with its simplifying as-sumptions, is still a hard problem, good progress hasbeen made over recent years (see [12]). This partlyled to the introduction of temporal planning (andplanning with resources) at the AIPS2002 planningcompetition [4], and is seen as a current major chal-lenge. The purpose of this work is to exploit existingclassical planning technologies with some commonsolving strategies from scheduling to solve tempo-ral planning problems, whilst exploiting any concur-rency where it is available in the problem.

Figure 1: Architecture Overview

Overview of the Architecture

I have designed a temporal planner that works by pre-processing durative action descriptions into collec-tions of instantaneous actions, building a plan usingthese actions with classical planning technology andthen postprocessing the resulting plan into a concur-rent plan.Figure 1 shows an abstracted overview of how thesystem works. Firstly, a temporal planning domainand problem is passed through a translator whichtakes out the temporal aspects, converting it to anequivalent STRIPSlike domain that preserves all thekey temporal relationships. It stores the duration ofthe actions that it has removed from the original filesin a separate file. These two STRIPS files are thenpassed through a classical planner. This is where the’hard’ work is done, but should be easier without thetemporal information. The totally ordered sequentialplan is passed through a program that produces a par-



tially ordered plan, allowing actions that can be exe-cuted together to happen concurrently, keeping onlyessential orderings in place. This partial ordering,along with the duration file created by the translator,are passed into a program that uses a simple tempo-ral network at its core. This calculates the relativeand actual timings of the actions, to produce a validtemporal plan. Each of the four main systems will belooked at in detail in the following section.

The System

The Translator and PDDL2.1

As with any planning technology, the choice of howthe problem is represented has a great impact on howthe problem is solved. What can be described canchange significantly how easy or hard the problemthen becomes. PDDL2.1 [3] seemed a natural choiceof description language for a number of reasons:

� It is an extension of PDDL [9], used in previousplanning competitions, which is the de facto lan-guage for classical planning. Therefore, transla-tion between PDDL2.1 and PDDL is simple (asdescribed later).

� As with PDDL, it is domain independent, so noadvice is given to the planner as to how to solvethe problem.

� PDDL2.1 is split into levels, corresponding tothe degree of expressiveness (and associated diffi-culty) of the problem.

� It is simple yet descriptive as to what it allows tohappen concurrently. Conditions may hold at thestart, at the end and over the duration of the action.Similarly, effects may happen at the start and endof the action, whilst some levels allow effects totake place over the duration of the action.

� PDDL2.1 was used in the AIPS2002 planningcompetition, so not only are there a number of do-mains readily available, but it is easy to comparethis system against other temporal planners thatentered the competition.

Figure 2: Translation from a Durative Action to 3 In-stantaneous Actions

There is one major subtly of the validity of PDDL2.1plans. Unlike classical planning, it is not just the or-der of the actions in the plan that ascertains its valid-ity, but also the times when the actions are scheduledto take place. A temporal plan is a sequence of timestamped actions with associated duration. It becomesunclear as to the validity of a plan if the end of oneaction deletes or achieves the precondition of the startof another action at the precise moment that that ac-tion is scheduled to start. That is to say, is it possibleto have� and�� true at the same time? On a morepractical note, any executive will only be able to exe-cute the plan to a certain degree of accuracy with re-gard to the timings. Therefore, PDDL2.1 introduces


https://www.researchgate.net/publication/220935951_Admissible_Heuristics_for_Optimal_Planning?el=1_x_8&enrichId=rgreq-a0179853301e215269b1676089e12005-XXX&enrichSource=Y292ZXJQYWdlOzIyMTE1MzMwNjtBUzo5NzU2Mjg3NDg3NTkxN0AxNDAwMjcyMjEwNzgw


’�’, or tolerance value: the minimum time betweenone action achieving another. If it is less than thisvalue then the plan is invalid according to PDDL2.1semantics [3].In the level of PDDL2.1 that this systems uses(level 3), continuous effects are not permitted in dura-tive actions. As mentioned earlier, PDDL2.1 durativeactions can have conditions that must hold at the startof the action or at the end of the action. Effects canalso occur at the start or at the end. Invariants arepropositions that must hold for the duration of the ac-tion. This conveniently allows a durative action to besplit into three instantaneous actions; one for the startwith its preconditions and effects, one for the endwith its preconditions and effects, and one to repre-sent the checking of the invariant. This can be shownin Figure 2. There are two extra dummy propositionsadded during the conversion process. The first, load-truck-inv, is an effect of the start and invariant actionand a condition of the invariant and end action. Thesecond, iload-truck-inv, is an effect of the invariantaction and a condition of the end action. These en-sure that if an end action is chosen, then so is thecorresponding invariant, and equally, if an invariantis chosen, then so is the corresponding start action.The translator converts durative actions in this way.It was originally written for LPGP [8], a temporalgraphplan based planner, and was only altered veryslightly so that it would work with the classical plan-ner described below. The durations file, for the exam-ple in figure 2, would contain an entry indicating thatthe LOAD-TRUCK action takes 2 time units. Thiscorresponds to the Simple Time domains used in thecompetition. The translator can also translate actionswith computed durations. In this case, it calculatesthe duration for all possible combinations of the de-pending parameters and writes these to the durationfile.

The Classical Planner

The classical planner used is FF. This is a success-ful forward heuristic plan-space search planner thatuses a heuristic created from a relaxed plan graph. It

takes in the translated domain and problem descrip-tion file and produces a totally ordered plan. Again,FF had to be altered slightly so that it not only printsout the actions that form the plan, but also the pre-conditions and the add and delete effects for each ofthose actions. This is necessary for the next stageto find out what actions achieve and threaten others.Also printed out are the goals of the problem. Again,this is used in finding the partial order.

for i = n down-to 1 do

1. for each�� Preconditions(��)Find an operator�� in plan with effect��Add an ordering from�� to ��

2. for each� � Delete-Effects(��)Find all operators with precondition, a deleteeffect of��Add an ordering from these to opi

3. for each�� PrimaryAdd(��) (if it ap-pears in the goal or sub-goal chain)Find all operators that delete any primaryadds of��Add an ordering from these to��

Figure 3: Total Order to Partial Order Algorithm

Total Order to Partial Order Conversion

To convert to the partial order plan, only those ac-tions that interact need be ordered. These arise intwo cases; firstly, where one action achieves an-other, and secondly, where one action threatens an-other by deleting a precondition. A greedy algo-rithm that works backwards through the plan, look-ing for achieving and threatening actions is used anddescribed in figure 3 [11]. Although this will not findan optimal plan, that is to say one that exploits allconcurrency possible, it is complete and sound (i.e. itwill find a valid partial order plan).As can be seen from step 3 of the algorithm, the goaland sub-goal chain are needed. Unfortunately these

https://www.researchgate.net/publication/2806378_Discovering_state_constraints_in_DISCOPLAN_Some_new_results?el=1_x_8&enrichId=rgreq-a0179853301e215269b1676089e12005-XXX&enrichSource=Y292ZXJQYWdlOzIyMTE1MzMwNjtBUzo5NzU2Mjg3NDg3NTkxN0AxNDAwMjcyMjEwNzgw


are lost after the planning phase. However, by recur-sively storing the preconditions of any actions thatachieve a goal or sub goal, these can soon be foundout again.

The Simple Temporal Network

Simple Temporal Networks (STNs) (as described in[1]) take a set of constraints of the form:

��

These describe the minimum�� and maximum��time between actions� � �� and are put into a graphfor reasoning, namely propagation of constraints, andchecking their satiability. The orderings from the par-tial order plan are converted into this form. The max-imum time between two ordered actions is infinityand the minimum 0.01 (or whatever� is set to). So ifLOAD-END must precede DRIVE-START:

��

However, if the ordering is an invariant action beforeanother action, it is made between the correspondingend action and the other action. If it is an invariantaction that occurs second, then the ordering is be-tween that action and the corresponding start actionof the invariant action. In both case, the minimumtime allowed to elapse is set to zero (i.e. the two ac-tions could abut). This happens because the invariantaction is not actually an instant, but the duration ofthe action. Therefore this does not need scheduling,but rather anything preceding it, must happen beforeor at the same time as the action starts, and anythingfollowing it must happen after, or at the same time asthe durative action finishes. This is all necessary forthe protection of invariant conditions.For this reason it is also important at this point tomatch up the corresponding start, end and invariantactions. It can be the case that there is more than onedurative action with the same name and parameters inthe plan. In this case there will be more than one ofits instantaneous actions. To match them up correctly(i.e. the correct start with the correct end), a greedy

approach is taken whereby the first start is matchedto the first invariant found, which in turn is matchedwith the first end action found for that combination ofparameters. And so forth through the plan. Identicalactions in the must have the same duration (even inTime domain variants) so it can never be the case thatthe classical planner had interleaved identical withthe intention of one action occurring and completingduring the duration of the other. If this were the case,the greedy approach would not work.Lastly, the durations are expressed as constraints.Once again it must be known which instantaneous ac-tions pair up to form durative actions. The constraintsexpressed state that the minimum and maximum timebetween the start and end action equals its duration.For example, if a drive action has a duration of 8, thenthe following constraint would be added to the STN:

� ��

Each constraint can be seen as two edges on a graphwith the weights representing the minimum and max-imum time differences, and the vertices being the in-stantaneous actions. In this system, the graph is rep-resented as an 2n+1 x 2n+1 array, where n is the num-ber of durative actions (and so 2n is the number ofstart and end actions, with the extra one as a specialtimepoint to represent the start of the plan). By run-ning Floyd-Warshalls [5] algorithm on this, the tran-sitive closure of the graph is be calculated.

Extracting the Durative Action Times

Once the transitive closure of the graph has been cal-culated, it is possible to look at the earliest and latestpossible times that any instantaneous action occurs.Figure 4 shows the greedy algorithm to find out theexact times at which the durative actions occur (i.e.at what time the start instantaneous actions occur).It continually finds the potentially latest finishing ac-tion, and then sets that to the earliest it could possiblyfinish. However, it then must recompute the transitiveclosure as changing this latest possible finishing timemay in turn change (although only ever decrease) the




latest possible finishing times of other actions. Com-puting this transitive closure with Floyd- Warshalls is�� and this must be done at most once for eachdurative action.

The plan finally produced, along with the originalproblem and domain file, can be passed into the val-idator [7] to check on its validity.

Find the latest possible instantaneous actionwhere its latest possible time does not equal itsearliest possible time.

1. Set this action’s latest possible time to equalits earliest possible time.

2. Re-compute transitive closure.

Loop until all actions latest and earliest possibletimes are equal.

Figure 4: Algorithm for Setting the Durative ActionTimes

Initial Results

To gain some initial results, the quality of the plansproduced and the time it takes to produce the planswere compared against LPG [6] and MIPS [2] on theDriverlog domain, both the Simple Time and Time(with computed durations) variants, as used in theAIPS2002 planning competition [4]. LPG is a plan-ner based on local search and planning graphs andwas awarded “Distinguished Performance of the FirstOrder” at the competition. The version used heretrades time spent planning to produce better qual-ity plans. MIPS works similar to this planner as itsplits up durative actions, and then combines sym-bolic and explicit heuristic search planning. It re-ceived the “Distinguished Performance” award. Ta-ble 1 compares the three planners in the Simple TimeDriverlog domain, and table 2 compares them in theTime Driverlog domain.

Table 1: Driverlog Simple Time Domain

Table 2: Driverlog Time Domain

As these are only initial results, and are only indica-tive, no formal analysis has been preformed on them.In the simple time domain, this planner would seemto scale better than LPG although at first slower. It isslower than MIPS, but scales at a similar rate. Whilstno optimisation has been performed on any of thecode I have written, the time to execute this code isinsignificant, with most of the time being spent plan-ning by FF. This planner consistently produces betterquality plans than MIPS, but equal or worse in qualitythan LPG.In the time variant, the picture is less clear. Whilst itis generally slower than MIPS, its performance variescompared to LPG. With regard to quality, it is gener-ally the poorest performer out of the three planners,although is still competitive.




Conclusions

I have achieved writing a version of “TemporalFF”for Simple Time, Time and, as described below, soon,Complex domains. The idea is similar to MIPS [2]as it uses pre and post processing of the domain andplan. But the planner described here is potentiallymore powerful as it has the ability to exploit start ef-fects of actions. This is because the translation phaseis structure preserving. Originality in this planner liesin its ’plug-ability’ as the language translator givesgenerality. As can be seen from Figure 1, it is pos-sible to replace any of the components, most impor-tantly the classical planner, with a functionally simi-lar program. This distinguishes it from MIPS whichany changes affect the whole algorithm. As is de-scribed next, replacing the planner with one with in-creased capabilities results in this planner inheritingthose capabilities without any other changes required.If the planner is replaced by a partial order planner,there would be no need to lift a partial order plan,reducing the effort needed.

Opportunities for Improvement

There are two main opportunities for improving thequality of the plans produced. The first is in the al-gorithm which lifts the partial order from the total or-der. As already observed, whilst this greedy approachis sound and complete, it may be the case that betterpartial order plans, which better exploit concurrency,could be found with some search. There would obvi-ously be a speed trade off here.The second opportunity is that of withdrawing thetimes from the STN. Rather than setting the latestpossible action to the same time as its earliest pos-sible time, it could be set to the next latest possibletime in the network. A shorter plan could be foundbut this may take longer to find.One idea to improve the efficiency of the system isto discard the need to send the invariant checking ac-tions to FF without a reduction of expressiveness orsoundness. The advantage of this would be two fold.Firstly, the search space would be smaller, and sec-

ondly, FF would need to do less work instantiatingthe actions (one observed problem with this planner).This would require more post processing as condi-tions and effects of the invariant would have to bemoved to the start action and then removed after-wards.

Further Work

As already observed, one potential change to the sys-tem is simply to change the classical planner. Thereare two obvious choices here. One is to use Met-ricFF, a variant of FF which would allow the use ofresources and other numeric values in the domain,and so tackle Complex domains. The second is touse a partial order planner. This would of course getrid of the need to lift the partial order plan as it couldbe taken straight from the planner.Currently, as all temporal information is taken out theproblem for FF, it cannot know the cost of the actionsit is using. It may well be the case that it is better touse a few short duration actions, rather than one longone. However, FF’s heuristic will choose the longerone as it tries to minimise the total number of actions,not the total duration. By incorporating the durationsinto the heuristic, this could improve the quality ofthe plans.

Bibliography

[1] Dechter R., Meiri J., and Pearl J. 1989. Tem-poral Constraint Networks. InProceedings from83-93 Principles of Knowledge Representationand Reasoning:83-93. Toronto, Canada.

[2] Edelkamp S., and Helmert M. 2000. On theImplementation of Mips. InProceedings fromthe Fourth Artificial Intelligence Planning andScheduling (AIPS), Workshop on Decision-Theoretic Planning.18-25 Breckenridge, Col-orado: AAAI-Press.

[3] Fox M., and Long D. 2001. PDDL2.1: An Ex-tension to PDDL for Expressing Temporal Plan-ning Domains, Technical Report, Departmentof Computer Science, University of Durham.



[4] Fox M., and Long D. 2002. The third Inter-national Planning Competition: Temporal andMetric Planning. InProceedings from the SixthInternational Conference on Artificial Intelli-gence Planning and Scheduling.115-117

[5] Gallo G., and Pallottion S. 1988. Shortest PathAlgorithms. InAnnals of Operations Research13:38-64.

[6] Gerevini A., and Serina I. 2002. LPG: a Plan-ner based on Local Search for Planning Graphs.In Proceedings of the Sixth Int. Conference onAI Planning and Scheduling (AIPS’02).AAAIPress.

[7] Howey R., and Long D. 2003 VAL’s Progress:The Automatic Validation Tool for PDDL2.1used in The International Planning Competi-tion. Forthcoming.

[8] Long D., and Fox M. 2002. Fast Temporal Plan-ning in a Graphplan Framework. InProceedingsfrom the Sixth International Conference on Ar-tificial Intelligence Planning and Scheduling.

[9] McDermott D., and the AIPS’98 PlanningCompetition Committee 1998. PDDL – ThePlanning Domain Definition Language. Techni-cal Report, Department of Computer Science,Yale University.

[10] McDermott D. 2000. The 1998 AI PlanningSystems Competition.AI Magazine2(2):35-55.

[11] Moreno D., Oddi A., Borrajo D., Cesta A., andMeziat D. 2002. Integrating Hybrid Reasonersfor Planning and Scheduling. InProceeding ofthe twenty-first workshop of the UK Planningand Scheduling Special Interest Group, 179-189.

[12] Weld, D.S. 1999. Recent Advances in AI Plan-ning.AI Magazine20(2).

Author Information

Keith Halsey Department of Computer Science,University of Durham, [email protected] �

ARTICLE

Automated Reasoning with Policies and Preferencial Monitors

Author: A. Mileo

Abstract

This short paper is a brief presentation of my re-search interests. I want to point to some areas Ihave addressed to, presenting my ideas about ap-plying Answer Set Programming (ASP) in model-ing different kind of systems where the automationof commonsense reasoning is a disirable objective.

Overview

This article describes this author’s research towardher PhD in Computer Science at University of Mi-lan, Italy. Broadly speaking, the topic of investiga-tion is logic-based Artificial Intelligence, and morespecifically the automation of commonsense reason-

ing. The theoretical framework of this research is thatof Answer Set Programming (ASP). ASP is based onthe stable modelssemantics for Logic Programs (or,equivalently, DATALOG) with default negations pro-posed by Gelfond and Lifschitz [8] [7]. ASP can beseen as bringing together concepts and results fromLogic Programming, Default Reasoning and Deduc-tive Databases. In ASP, a logic program (or, equiv-alently, a DATALOG intensional database) is givena meaning in terms of alternative models that are i)compatible with the rules of the program and ii) truth-minimal.

Within the theoretical framework illustrated above,we consider the following question:what is reason-ing with rules and defaults in a networked scenario?



By a networked scenario we intend a collection ofindependent devices, each of them running a controlprogram inside, that are connected to a network andcan communicate intelligibly, thanks to some sharedprotocol. This devices are independent yet they nor-mally serviceeach other. We have different degreesof information: completeand incomplete. Also, de-pending on the network, we may have different lev-els of completeness of information. This scenario isakin to that of multi-agent systems, which are notdiscussed in this paper (Multi-agent Systems (MAS)are communities of problem-solving entities that canperceive and act upon their environments to achieveindividual goals as well as joint goals. Their coop-eration is based on sharing knowledge to learn asmuch as they need to successfully achive their com-mon goals.).Unlike themonolithic scenario normally consideredin Logic Programming (resp. deductive database),where one or more programs run on the same com-puter, sharing central memory and cooperating tocompute the goal (resp. query), in a networked sce-nario programs running on disparate devices may nothave the same objective, and may pursue selfishlytheir own [17]. Yet, much like in economics, ex-change and cooperation may happen to the benefit ofall (The networked scenario matches with the Web,somewhat, but it should not be identified with it. Forinstance, the network routing scenario considered byLobo and his co-authors in the development of PDL[4] is networked but differs from the Web in severalaspects.).In networking, the notion of policy is nowadays of-ten used, and in what follows we will often work ontheories that are called policies.In my PhD work, I will propose an interpretationof rule- and default-based reasoning adequate to thenetworked scenario described above. The methodol-ogy is that of proposing incrementally more expres-sive extension of the common event-condition-actionrule schema of active databases.Indeed, my work has started from that of [4] on thelanguage PDL (Policy Description Language), whichhas been developed at Bell Labs for the specification

and execution of policies governing network router orsimilar devices [3]. PDL can be seen as the applica-tion of database triggers to the networked scenario,plus a consistency maintenance mechanism, calledmonitor, that prevents the application of conflictingrules. PDL policies can be executed either throughad hoc interpreter or through translation into AnswerSet Programs. From the standpoint of ASP, PDL is avery simple language, free from recursion.In my work I have proposed and studied in depth sev-eral extensions of PDL that capture aspects of thenetworked scenario which are believed to be relevantand complex to tackle. The first extension I proposedfor PDL is the possibility to describe user preferencesin conflict resolution [9]. Allowing user preferenceshowever interacts with themaximality requirement,i.e., that a network device should satisfy the max-imum possible number of requests in subtle ways,which often require a compromise [10]To validate this approach, and to characterize newtypes of reasoning that should be modeled, more ex-perimentation is needed. I plan to apply my own ver-sion of PDL in less deterministic, more incompletescenarios than the one where PDL was conceived.The following is a list of applications I intend to con-sider

� Universal Communication Identifier Systems [15]

� Policies for network monitoring

� Semantic Web search and consultation [16]

To sum it up, my research work is about bringingautomated commonsense (nonmonotonic) reasoningto a networked scenario proceedingfrom the bottomup, i.e., from low-complexity languages in the well-defined setting of network routing to an increasinglyopen, non-deterministic scenario typical of the Web.I chose to proceed by extending PDL rather than byadapting the highly expressive language of ASP: thebottom-up approach showed allow us to control theintroduction of expressiveness – and therefore com-plexity – at every step.This approach is somewhat complementary to a cur-rent line of investigation in my research group [13],





https://www.researchgate.net/publication/2952717_An_Iterative_Algorithm_for_Synthesizing_Invariants?el=1_x_8&enrichId=rgreq-a0179853301e215269b1676089e12005-XXX&enrichSource=Y292ZXJQYWdlOzIyMTE1MzMwNjtBUzo5NzU2Mjg3NDg3NTkxN0AxNDAwMjcyMjEwNzgw


where ASP is being applied directly to Semantic Webpages written in the language RDF [12], which is amost complex artifact sitting on top of several net-work and web layers.

Policies and Monitors in Answer SetProgramming

Policies are widely used and play a relevant role inseveral different contexts, such as network manage-ment, access control, trust management and telecom-munication systems [19]. We believe that policyspecification and enforcement can be a key enablingtechnology for intelligent systems. Many of those en-vironments are, however, characterized by complexpolicies, taking into account a large variety of events,conditions and actions to be executed. Developingand analyzing a given collection of policies can bethus quite a complex tasks, in particular if one wantsto ensurepolicy consistency, that is for example, thatno two different policies result in conflicting actionsto be executed. In order to address such a require-ment, declarative approaches to policy specificationappear to be a promising solution.This is an important and non trivial issue that I wantto treat in my doctoral work by addressing an high-level language as I will show later in this paper.

A brief Introduction to PDL

[4] define a policy as a set of rules of the form

�� causes� if �

where C is a Boolean condition,�� are eventsthat can be observed in our system, and� is an ac-tion that the system administrator may perform. Inmy work I adopt Lobo’s definition of policy. PDLhas been extended by its own creators by the intro-duction of consistency monitors, sets of constraintsof the form

never �� if �

Monitors prevent execution of conflicting actions andimply a maximal number of executable actions in the

sense of set containment [4]. In [9] we showed how,in our opinion, some issues such as maximality of thesolution, needed further careful consideration, espe-cially if we want to make PDL with monitors an ap-pealing specification language also outside networkmanagement.

PDL in ASP

The formal (declarative) semantics of a PDL policyplus monitor is given by [4] throughout a translationinto propositional logic programs under Answer SetSemantics. In my work I am adopting the same strat-egy, aiming not only the clean, well-studied formalsemantics of ASP, but also the possibility to applyASP to computing PDL theories.With ASP we can realize non-monotonic reason-ing and encode many interesting (albeit intractable)search and decision problems by computing all pos-sible solutions to them (Answer Sets). ASP allowsdeclarative problem-solving based on the applicationof defaultrules, i.e., the drawing of conclusion basedon lack of evidence of the contrary.Moreover, nowadays there are rather efficient solvers[18] that can compute the answer sets of programsdefining thousands of atoms within few seconds. Inparticular, the solverDLV computes answer sets ofprograms with disjunctions and Psmodels (an exten-tion of Smodels), can compute priorities [5], [14].Hence we found ASP is a suitable approach to au-tomate commonsense reasoning.

Extending PDL

Whereas it is still non trivial to define sets of rulesdirectly in ASP because of complex policies an envi-ronment should be controlled by, PDL gives us a sim-ple tool to define policies and a well-studied mappingsystem from PDL to ASP would fit our purpose.This has been done by Lobo et al. in theiroriginalPDL. It worked as a transducer (stateless) and it waslinear. But maximal solutions we get from it are notalways those that PDL users may expect. In [9] weanalysed PDL and found that sometimes we should








be better interested in investigating monitors thatyield maximum sets(in the sense of set-cardinality) ofactions as a result. We argued that such monitors cap-ture more closely the intended meaning of a monitor,albeit their application may become computationallyintractable.In our subsequent work, we considered a further ex-tension of PDL that allows user-defined preferenceson how to apply monitors [11]. As a result from ap-plication of such monitors, we may expect to obtaina set of actions that maximize user’s satisfaction ac-cording to user’s preferences, even though such setsare neithermaximalnor maximum. In network man-agement, for example, it is interesting to notice thatmaximality is not part of the design philosophy ofthe networking protocol IP, where a device seems tobe under no obligation to answer to a maximum num-ber of requests: unanswered requests may just be re-peated, albeit at the expense of network traffic.I am interested in investigating whether the maximal-ity requirement is a strong requirement in many com-mon applications, or it can be – at least partially re-leased. I believe that flexible policy languages, withunderlying formal semantics, are required by whichapplications can specify whether to enforce or not themaximality requirement.This further extention of PDL with preferences alsoincreases the computational complexity. However,using PDL instead of writing policies directly in ASPallows us to perform easier complexity analysis, andcould enable us to apply optimized translation to getfaster ASP programs.In literature there are several approaches dealing withpreferences [6]. In our work we adopt Brewka con-cept of preferences expressed in Logic Programmingwith Ordered Disjunction [5].

Applications

The Policy Definition Language with Preferences(PPDL) that we are developing, has been initiallyconceived for network management. Another direc-tion of work that I want to pursue concerns the mod-eling of routing policies for unified messaging sys-

tems; the idea is to assess PDL and ASP usability inthis context and to devise new extensions to PDL lan-guages. This context can be described ascooperativeservices, i.e., all the units in the system work togetherto achieve a common goal. There are also other envi-ronments, such as general Web services and Seman-ticWeb, which we callsemi-cooperative. I will dis-cuss the applicability of PPDL in such contexts in thefollowing sections.

Universal Comunication Identifier (UCI)systems

Recent technologies for comunications devices en-able users to have various means by which they cancomunicate each other and exchange data anywhereand anytime. However, to do so, different phonenumbers and addresses should be disclosed and thisbecomes even more complicated when user’s reacha-bility depends on some conditions. To address such aproblem, a rule language to express policies, based onECA paradigm, has been introduced in UCI systems[15]. A user subscribing an UCI system has a unique,deviceindependent identifier and messages are prop-erly routed to the appropriate device according to thespecified rules (policy).All this rules are stored according to a stream rep-resentation in a database, and all rules are fetched,even when they are not enabled. I think that usinga properly extended version of our language PPDLwe could give an alternative time-saving strategy thatimproves the performance and degree of adaptabilityof the rule selection process.

Policies for Network Monitoring

One of the first field in which policies, formulatedas sets of ECA rules, have been applied, is networkmanagement and monitoring [4].I’ve found that Policy Description Language used inthis context has several limits I’ve investigated in:

� No backtrack is expected (there are only positiveevents, the framework ismonotonic);

� Policies represent onlystatelesstransducers;






� Only a built-in concept of minimality is consid-ered; no preferences and no maximal sets of ac-tions as a result are contemplated.

My alternative approach, based on PPDL is expectedto treat negated events, preferences, states, maxi-mal solutions. Nevertheless, to monitor such generalnetworks, additional computational complexity is in-evitable.

PPDL and Semantic Web Search

Following [16], [1] and other authors, the Seman-tic Web (SW) can be seen as an abstract represen-tation and exchange of data and metadata. In Re-source Description Framework (RDF), these meta-data consists in resource descriptions, given in termsof data markup and reference to shared, univer-sally agreed, web-accessible definitions (calledon-tologies) that, combined, provide theintended mean-ing of the terms.

[16] presented a client-server application called Se-mantic Search to improve traditional Web Search-ing strategies in Semantic Web, where different sitesmight provide different kinds of data about an ob-jects. This lack of uniformity can enable us to exploitnew and interesting pieces of data from the SemanticWeb, but it can also be problematic in several Seman-tic Web applications, such as Semantic Search. In thiscontext, when ambiguity arises (more than one termin the Semantic Web contain the search term), all dif-ferent notation should be taken into account, but wehave to pick one of these as apreferrednotation, anddetermine what data should be shown and in what or-der.

I believe that our approach, based on ASP, could besuccessfully applied to enable users to define theirown set of preferences in Semantic Web search. Theidea is that of replacing ad-hoc search algorithms bydeclarativesearch policieswritten in a proper versionof PPDL.

Conclusions

The high-level language for policies I want to pro-pose would automate interesting type of reasoning inthe networked scenario. To achieve these goals, I amforseeing a long-term project that will include exper-iments to evaluate real limits and advantages of thisapproach. A comparison with other theories, expe-cially planning, should also be attempted.

Bibliography

[1] Grosof, B., 2002.Rules + Ontologies for Se-mantic Web Services. U. Maryland seminar talk,ebusiness.mit.edu/bgrosof/#PapersEtc

[2] Eiter T., Gottlob G. and Mannila H., 1997.Disjunctive Datalog. ACM Transactions onDatabases, 22(3):364-417.

[3] Lobo J., Bhatia R. and Naqvi S., 1999. A PolicyDescription Language, inAAAI/IAAI, 1999, pp.291-298.

[4] Chomicki J., Lobo J. and Naqvi S., 2003.Conflict Resolution using Logic Programming.IEEE Transactions on Knowledge and Data En-gineering (TKDE) 15(1): 244-249.

[5] Brewka G., 2002. Logic Programming with Or-dered Disjunction Proc ofAAAI02.

[6] Schaub, T. and Wang K., 2001. A semanticframework for preference handling in answerset programming. TPLP 3(4-5): 569-607 (2003)

[7] Gelfond, M. and Lifschitz, V., 1991. Classi-cal negation in logic programs and disjunctivedatabases. New Generation Computing: 365-387.

[8] Gelfond, M. and Lifschitz, V., 1988. The Sta-ble Model Semantics for Logic Programming.ICLP/SLP 1988: 1070-1080.

[9] Bertino, E., Mileo, A. and Provetti, A., 2003.PDL with Maximum Consistency Monitors.Proc. ofISMIS03. In press.




[10] Bertino, E., Mileo, A. and Provetti, A., 2003.User Preferences VS Minimality in PPDL.Proc. ofAGP03. In press.

[11] Bertino, E., Mileo, A. and Provetti, A., 2003.Policy monitoring with User Preferences inPDL. Proc. ofNRAC03. In press.

[12] Bertino, E., Provetti, A. and Salvetti, F., 2003.Local Closed-World Assumptions for reason-ing about Semantic Web data. Proc. of AGP03,APPIA-GULP-PRODE. In press.

[13] Web location of the Milan-Messina ActionGroup:mag.dsi.unimi.it.

[14] Web location of the Psmodels solver:www.tcs.

hut.fi/Software/smodels/priority/.

[15] Bertino, E., Cochinwala, M. and Mesiti, M.,2002. UCS-Router: A Policy Engine for En-forcing Message Routing Rules in a UniversalCommunication System. Mobile Data Manage-ment 2002: 8-

[16] Guha, R.V., McCool, R. and Miller, E., 2003.Semantic search. WWW 2003: 700-709.

[17] Papadimitriou, C., 2003. Lectire at Lipari Sum-mer School. Manuscript.

[18] Web location of the most known ASP solvers.Cmodels:www.cs.utexas.edu/users/yuliya/

aspps:www.cs.uky.edu/ai/aspps/DLV: www.dbai.tuwien.ac.at/proj/dlv/Smodels: www.tcs.hut.fi/Software/

smodels/

[19] Virmani, J., Lobo, L. and Kohli, M., 2000.NET-MON: Network Management for the SARASSoftswitchProc. of IEEE/IFIP Network Oper-ations and Management Symposium.

Author Information

Alessandra Mileo Dipartimento d’Informatica eComunicazione Universit`a degli studi di Milano. Mi-lan, I-20135 [email protected] �

ARTICLE

Multi-Agent Planning Architecture for Autonomous Robots

Author: B. Innocenti, B. Lopez, and J. Salvi

Introduction

The challenge of developing autonomous robots in-volves several related problems as dynamical mod-eling of the world, task and path planning, planningand scheduling, etc..Traditionally, each problem has been solved and im-plemented in a module based architecture, where therelationships among all components are establishedat the design time. This kind of architectures con-strains in some way the possible outcome when therobot has to perform a task. This fact leads re-searchers either to focus on new, more flexible ar-chitectures, or to develop collections of autonomousrobots that coordinate their activities to solve com-

plex tasks. In the later, multi-agent architectures havebeen applied in order to have a global behavior ofthe agent population. An agent in such approach isequivalent to a robot.

Our proposal is the other way around and it is re-lated to the last approach, that is, how to build robotarchitecture based on multi-agent system (MAS). Inthis proposal all the agents constitute a single robot.Agents have the same global goal: to control therobot and to do it intelligently, while fighting for re-sources. So, planning tasks and actions is required inorder to maximize the robot performance. We believeour approach will allow to have a more robust, flex-ible, reusable, generic and reliable architecture that


https://www.researchgate.net/publication/3942843_UCS-Router_a_policy_engine_for_enforcing_message_routing_rules_in_a_universal_communication_system?el=1_x_8&enrichId=rgreq-a0179853301e215269b1676089e12005-XXX&enrichSource=Y292ZXJQYWdlOzIyMTE1MzMwNjtBUzo5NzU2Mjg3NDg3NTkxN0AxNDAwMjcyMjEwNzgw





https://www.researchgate.net/publication/220903188_Local_Closed-World_Assumptions_for_reasoning_about_Semantic_Web_data?el=1_x_8&enrichId=rgreq-a0179853301e215269b1676089e12005-XXX&enrichSource=Y292ZXJQYWdlOzIyMTE1MzMwNjtBUzo5NzU2Mjg3NDg3NTkxN0AxNDAwMjcyMjEwNzgw





can be easily modified and completed to permit so-cial behavior among robots.

Background

At Girona University we apply MAS in the soccerrobotic team, RoGi Team. In robotic soccer, teamsare composed of 4 players and a goal-keeper. Po-sition of robots (teammates and opponents) and theball is obtained by a global vision system, with thecamera put 3 meters above the field. This yields tohave a relative global knowledge of the environment.

Figure 1: RoGI Team

As a MAS system, each robot is an intelligent physi-cal agent with a role assigned, as in real soccer teams[1] [2] [3] [4]. Each role (goalkeeper, attacker, de-fense, etc.) has a set of possible actions to do (go forthe ball, defense a zone, pass the ball to a teammate,etc.). In order to choose the best action to do as awhole team, the decision process of each agent takestwo clearly defined steps: the first one consist in eval-uate as an individual which of the possible actions isthe most feasible (according to distance to the ball,opponents near robot, distance to the opponent goal,etc..) and the second one lies in the communicationof this decision to teammates so as conflictive situa-tions (as two robots going for the ball) can be avoid(based on the role of the agent in the team, position,etc.). As a result of this step one agent may have tochange the selected action. Once the team reaches anagreement, each agent executes the selected action.

Our MAS lacks of team or individual planning,agents are purely reactive, due to, among others, thespeed of the game; robots are extremely fast and deci-sions must be made in milliseconds. Soccer is a verydynamic environment.Figure 1 shows the robots that form RoGi SoccerTeam.In spite of the soccer environment, we believe that theplanning component is a key issue for any robot thatacts autonomously. So, we start analyzing the robotarchitecture to provide such functionality.

Ongoing Research

The main feature of this research is the multi-agentarchitecture for controlling one autonomous robot.This MAS is composed of some specific agentsnamely the task planner agent, the reactive agent, andthe monitor agent. These specific agents can be, atthe same time, multi-agent systems. Finally, the re-sulting architecture is formed by several abstractionslevels of MAS (see Figure 2).First, the task planner agent is in charge of providinga plan according to some given goal or set of goals.It is, in fact, a multi-agent system form by severalplanner agents and a coordinator agent.

Figure 2: Task planner multi-agent system



The key agent in the task planner agent MAS is theCoordinator Agent, which asks to the planner agentsfor plan or a sub-plan. The idea is to have severalexisting planners that can be suitable for different sit-uation (in some cases some of them can may not pro-vide a solution or the solution may not be the best)or that can provide the solution at different time. TheCoordinator Agent knows which planner is appropri-ate for each situation and asks it for a plan. In case ofan unexpected event, it asks for re-planning or even itcan ask to some planners to give a sub-plan for spe-cific parts of the whole plan.

Figure 3: Pioneer Robot

Second, the reactive agent deals with obstacle avoid-ance and similar issues. Finally, the monitor agenttracks the execution of the current plan in order todetect on time, possible failures.So as to avoid ad-hoc MAS platform, we haveadopted Open Agent Architecture (OAA). This plat-form is developed and maintained by the SRI team[5] cite6. It presents some advantages over othermulti-agent platforms including that agents can beprogrammed in C++, an important aspect to considerif we want to re-use some of the existing code. An-other characteristic is that OAA has been integratedwith Saphira. We use Saphira to develop the reac-tive agent and Saphira (also from de SRI team) is thesoftware that comes with the pioneer mobile robot,the one used in this project [7] (see Figure 3).

OAA has some particular agents to guarantee a cor-rect functioning of the platform, as can be the Fa-cilitator agent, which provides the agent communitywith a number of services for routing and delegatingtasks and information among agents. The role of thisagent is important because it is where, upon connec-tion, each agent registers its functional capabilitiesand specifications of its public data. Moreover whena request is send to the agent community specifying ata high level the description of the task along with op-tional constraints and advice on how the task shouldbe resolved, the Facilitator agent distributes subpartsof the task among agents and coordinates their globalactivity. So, Facilitator agent is the one who will havethe knowledge of the different agents that form theproposed architecture, where they are, and the capa-bilities of each one.

Example

To clarify some ideas we propose an example. Let’sconsider a surveillance robot that has to move aroundin a building while taking pictures of some specificrooms. The map of the building is shown in Figure 4.

Figure 4: Floor of the building of the surveillancerobot

The actions that the robot can do are: move(from,to),check-alarm and take-photo. Let’s supposed that therobot is in Room R2 and must do the following plan:




{move(R2,Hall),move(Hall,R1),take-photo,move(R1,Hall),move(Hall,R11),take-photo,move(R11,Hall)}

The robot starts to execute the plan and when it isin Room R1 taking the picture, there is an alarm inRoom R21. At this moment, the Coordination Agentasks to two proper planner agents, for a sub-plan thatconsiders going to R21 to check the alarm. The an-swers are:Planner Agent 1:

{move(R1,R21),check-alarm,move(R21,R1),move(R1,Hall)}

Planner Agent 2:

{move(R1,R21),check-alarm,move(R21,Hall)}

The proposed sub-plan of Planner Agent 2 may be thebest because it puts the robot near the next objectivethat is Room 11. Under this belief the CoordinationAgent can modify the original plan to be:Final Plan (Coordination Agent): move(R1,R21),check-alarm,move(R21,Hall),move(Hall,R11),take-photo,move(R11,Hall)And the robot continues its execution.

Conclusions

The ideas proposed in this paper are a preliminarystudy. At the moment, within OAA we have imple-mented three planner agents, by agentifying the exist-ing planners Prodigy, Temporal Graphplan and Sen-sory Graphplan. Next, we will focus on the coordi-nation agent.

Bibliography

[1] Examples of Dynamical Physical Agents forMulti Robot Control. Innocenti, B., de la Rosa

et al. 2. Workshop Hispano-Luso de AgentesFısicos Madrid 2001. Spain.

[2] An Example of Dynamical Physical Agents. Dela Rosa, J.Ll., Innocenti, B., Oller, A.et al. Eu-ropean Robocup Workshop. 2000. Holland.

[3] Rational Dynamical Physical Agents. De laRosa, J.Ll., Garcia, R., Innocenti, B., et al.3rd Robocup Workshop. Vol. on RoboCup-99:Robot Soccer World Cup III, Lecture Notes inAI No.1395, Eds. Springer-Verlag.

[4] Rogi Team Real: Research on Physical Agents.De la Rosa, J. Ll., Garc´ıa, R., Innocenti, B., etal. 3rd Robocup Workshop. Vol. on RoboCup-99: Robot Soccer World Cup III, Lecture Notesin AI No.1395, Eds. Springer-Verlag.

[5] Building Distributed Software Systems withthe Open Agent Architecture. Martin, D.L.,Cheyer A.J. and Moran D.B., in Proc. of theThird International Conference on the Practi-cal Application of Intelligent Agents and Multi-Agent Technology, Blackpool, Lancashire, UK,1998.

[6] The Open Agent Architecture: a frameworkfor building distributed software systems. Mar-tin D., Cheyer A.J., and Moran D.B., AppliedArtificial Intelligence 13, pp 91-128, 1999.

[7] Many Robots Make Short Work. Guzzoni, D.,Cheyer A., Julia L., and Konolige K., AI Maga-zine 18(1), pp 55-64, 1997.

Author Information

Bianca Innocenti Badano, Beatriz Lopez,and Joaquim Salvi Agents Research Labora-tory / Computer Vision and Robotics Group, Institutd’Informatica i Aplicacions, Universitat de Girona{bianca,blopez,qsalvi}@eia.udg.es �


ARTICLE

Optimal Heuristic Planning using Search Space Splitting

Author: Y. Zemali

Introduction

Heuristic search has been widely applied to classi-cal planning and has proven its efficiency in find-ing a “good and feasible” plan as quickly as possi-ble. Finding the optimal solution (either in terms ofplan length or of other criteria) remains an NP-hardproblem [5]. Complete and optimal planners requirean exponential computation time in the worst case,while a number of heuristic planners propose effi-cient approximative schemes [11]: those planners areoften neither complete, nor optimal. GraphPlan [1]is complete and optimal: it finds the shortest par-allel plan in STRIPS problems. However, it canbe interpreted as a heuristic planner [3]: GraphPlanperforms an approximate reachability analysis by ne-glecting some constraints, except for the binarymu-tex relations. In terms of heuristic search, the plan-ning graph building phase allows to assess alowerbound of the lengthof this shortest parallel plan. Thecomputed heuristic is admissible, but less informa-tive than the non-admissible heuristic used in [10].Good heuristics can generally be computed by solv-ing a relaxed problem, but it may be difficult to takeinto account enough constraints with a quick compu-tation method: the relaxed problem should not maketoo strong assumptions about the independence ofsubgoals. There seems to exist acompromiseto beachieved between computational efficiency and qual-ity, namelyadmissibility and accuracy, of the heuris-tic. We propose and formalizesearch spacesplittingas a general framework allowing to neglect or takeinto account a controlled part of the problem con-straints (e.g. negative interactions) [18], and use it inorder to compute a variety ofinformative admissibleheuristics, then applicable in an�� informed searchalgorithm foroptimal planning.We first present related recent developments inheuristic planning. We formalizeState space splitting

as a flexible planning scheme and present how to useit in order to compute a range ofinformative admis-sible heuristics. Finally, we comparesplitting strate-gies in terms of the computational cost of obtainingan informative admissible heuristic and also in termsof the benefit obtained from using that heuristic atsearch stage with an�� algorithm.

Issues

A planning heuristic can be computed by consider-ing a relaxed problem that is much quicker to solve.HSP [2] computes its heuristic by assuming that sub-goals are independent: it does not take any interactioninto account.HSPr [3] takes some negative interac-tions into account while computing its heuristic anduses a�� algorithm performing a backward searchfrom the goal to find a valid plan.HSPr* [9] com-putes an admissible heuristic using a shortest path al-gorithm. It finds an optimal solution using an IDA*algorithm to search the regression space.HSP 2.0[4] is a planner that allows to switch between severalheuristics with a�� search algorithm.FF [10]uses a relaxed GraphPlan (without mutex propaga-tion nor backtrack) to compute anapproximation ofthe lengthof the solution, i.e. the length of a solutionto the relaxed problem: this heuristic takes into ac-count some positive interactions, but no negative ef-fects: therefore it isnot a lower bound and not an ad-missible heuristic. The search is performed using anenforced hill-climbingalgorithm, switching to��

in tougher problems.Inferring state invariants can help reducing the plan-ning complexity: invariants are properties that hold inall the states that are reachable from an initial state.[16] propose a polynomial iterative fix-point algo-rithm to infer 2-literals invariants, such as permanentmutex relations. TIM [6] computes GraphPlan’s per-manent mutex relations as a pre-processor forSTAN






[13]: it generates finite state machines for all thepossible transitions for each single object in the do-main. Yet, the benefit of pre-computing permanentmutex relations appears as not significative enough inGraphPlan-like approaches, such as in [7] or [14]. Ageneralization to other invariants is proposed in [17]and in theDISCOPLAN package [8] which uses syn-tactic properties of the operators to verify whether thetruth of an invariant is preserved. Such invariants orproperties of the domains can rather be used in orderto speed up heuristic computation. “Hybrid” plan-ners efficiently combine both approaches :AltAlt[15] computes its heuristic using the planning graphproduced bySTAN, and searches from the goal withHSPr’s regression algorithm.

States and facts

The duality between state-based and fact-based rep-resentations is classical: a planning problem can bedescribed either with a model based on enumeratedstates or with a model based on facts that can be trueof false. Both representations characterize the samestate space: enumerating all the possible combina-tions of truth values for the facts gives the set of allpossible states. Each fact corresponds to the set ofstates in which it is true. Each list of facts corre-sponds to the set of states in which all the facts aretrue (the intersection of the sets of states correspond-ing to each individual fact).

State-based model

In a state-based model, actions are defined as transi-tions between individual states: in each state, an ac-tion can either be executable, leading to another state� �� , or not. The state-based model of a plan-ning problem is defined by:

� a finite possible states set��

� a finite possible actions set� ��

� a transition function�� associating to each couple (state, action)�� :

– either an impossibility symbol if the action�is not executable in the state� ��

– either the state�� resulting from the exe-cution of action� in state� �� .

Fact-based model

In a fact-based model, actions are defined as oper-ators that make some fact true and other fact false,provided a number of facts that have to be true forthe action to be executable. Each action is definedby:

� a list1 of preconditions��, that is to say the factsthat have to be true for the action to be applicable;

� a list of deletion��, that is to say the facts thatare made false by the application of the action;

� a list of creation��, that is to say the facts that aremade true by the application of the action.

An operator defines a macro-transition from a list offacts (a set of states) to another list of facts (anotherset of states): The fact-based model of a planningproblem is defined by:

� a finite set of facts describing the properties of thepossible states� � ��

� a finite possible actions set� � � � ��

� a transition function�� associating each couple��

– either to an impossibility symbol if �’s pre-conditions do not hold in�, i.e.�� .

– either to the set of facts � � resulting fromthe execution of action� � �� in thestates where facts� hold�� , with � ��

We define the set as the set ofrelaxed actions(actions obtained from by neglecting the deletelists). We have:�� and� � � �� !�� . We note�

�

the associated transition relation.1in GraphPlan parlance, list means set (no ordering between the elements)




Search space

The planning can either be done from the problemdefinition or after an exploration phase that builds thegraph of thesearch space. Depending on how it han-dles facts or states and how it develops the transitionrelation between them, a planner will not build thesame search space nor explore it in the same way. Theclassical duality between facts and states is the basisof our formalization of a variable state space splittingin the building and exploration of the reachable statesat planning time.

Tree search space at state level

In a tree search space, all the nodes� of the exploredtree correspond exactly to individual states� � ��.The nodes are connected by the possible transitionsbetween states. The transition relation�� betweenthe explored nodes in an tree search space is directlygiven by the transition function�� of the state-basedmodel. �� is the successor of�� in the searchtree and in the transition relation��, if and onlyif there exists an action that realizes a transition be-tween these two corresponding states. Developingsuch a transition relation gives the tree of aForwardState Spacesearch.State-based transition relation��

� � � ��

Disjunctive search space

In a disjunctive planning approach, the nodes of thesearch spaceare the levels, which correspond to thenotion of depth in a tree: there is only one node bydepth.The successor node�� at level" � � is the set offacts �#�� #�� #��

� built by developing allthe transitions that are applicable from the set of factsof its predecessor node�� #�� #

�� #

�� at level

" (taking mutexes into account).The transition relation�� between the nodes of adisjunctive planning graph is deduced from the tran-sition function�� of the fact-based model:

Disjunctive transition relation ��

� ��

��

� ��

��

A splitted search space?

The idea ofsearch space splittingis to reintroduce acontrolled tree structurein a disjunctive search spaceby grouping the facts at each level" in different nodesinstead of one undistinguished set of facts��. Forthat purpose, it is necessary tosplit the level into dif-ferentnodesconstitutive of the tree structure.This can be done in many ways over the set�� ofsubsets of��, and in particular the splittingneed notbe a partition. On the contrary, useful splitting strate-gies are more likely to let each fact belong to a list ofnodes, or classes:Classes:at each level", the facts of�� are groupedinto a finite number of subsets that we call classes�� with indexes$ � �� . Each class

in a level" corresponds to anode��

�

of depth" inthe tree of the search space.The set of all classes at a level" is denoted��

� �� . �� is acoveringof �� .

How to split the planning graph

The splitting strategy defines the rules for creatingand propagating classes, thus associating each classat a given level with its successor classes at the fol-lowing level. In that sense, the splitting strategy is the“branching rule” of the tree structure introduced inthe planning graph. Classes are defined while build-ing the search space as a tree.Splitting strategy: �� if � is a class creator,� otherwise.The splitting strategy consists in determining whichactions will create a new class when they will be ap-plied. Those actions will be applied through�� (theirdelete lists will be taken into account). Other actionswill be applied through�� (as relaxed actions, i.e.

without their delete lists). From a departure class�� ,an action� is applied in the following manner:



� if ��

�� where% is a

new index for the created class;

� if ��

� ��

� where� � is the relaxed action corresponding tothe action�.

Figure 1: Splitting process for the gripper domain

The resulting transition relation in the search spaceconnects two nodes, i.e. a couple of two classes(de-parture, arrival) of two successive levels, if and onlyif, for all facts in the arrival class:

� there exists an action whose preconditions are alltrue in a same departure class and that has this factas an effect in the arrival class;

� the application of this specific action in the de-parture class effectively leads to the arrival classaccording to thesplitting strategy.

This transition relation not only requires that the factsin each class are connected by the fact-based transi-tion relation�� or �

� , but also that this is coherentwith thesplitting strategy.Splitted transition relation: ��

�

� ��

��

� � ��

if � � ��

� � � ��

�

��

if � � ��

� � � ��

�

��

� ��

A no splitting approach(� � � � �� )corresponds to a GraphPlan behavior. Afull splittinapproach(� � � � �� ) corresponds tothe behavior of aForward State Space plan-ner.

Getting informative admissible heuristics

In GraphPlan, the number of levels of the planninggraph (when the goals are first reached) may be a verypoor estimation of the exact length of the solution: inthis building phase, GraphPlan relaxes a number ofconstraints. It groups together incompatible facts intosets (levels) that contains a number of incoherences.

On the contrary, a full splitting approach (a tree ex-ploration) will separate each individual state duringthe graph construction. The depth of the planning treewhen the goals are first reached, will give the exactlength of an optimal solution. GraphPlan’s approx-imation is too coarse (too short). A tree explorationwill compute a perfect heuristic, but in an exponentialtime.

We usestate space splittingin order to achieve acom-promisebetween those two extremes: our heuristic isclassically computed by solving a relaxed problem,i.e. having neglected some constraints, but uses thenumber of levels of thesplitted planning graph.

Splitting the planning graphallows us to better ap-proximate the real plan length (see also [12]), tak-ing more negative effects into account in a controlledway: a number of incoherent sets of states can besplitted, and more constraints of the problem can betaken into account. As a consequence, some opera-tors will not be introduced as early as in a GraphPlan-like building phase. Therefore, the length of the plan-ning graph (when it first reaches the goals) isin-creasedgetting closer to the real optimal plan length.Yet, we are still underestimating the exact plan lengthbecause not all the constraints are taken into consid-eration. The length of the splitted planning graph isamore informative admissible heuristic.

Splitting on the number of permanentmutexes

Our splitting strategy is based on mutual incoherence,or interactivity, between facts. At each level, facts aregrouped according to their level of mutual coherence


with respect to the problem constraints: facts createdby operators that are not mutex with each other canbe grouped in a same class. In practice, operatorswith a big interaction degree (this is the number ofinstantiated operators with which the current operatoris permanently mutex) are marked as “class creator”.A number of algorithms allow to compute invariantsfeatures such as permanent mutexes in a planningproblem. We designed an algorithm, devoted to thedetection of permanent mutex relations, which con-siders facts as resources [14]: if two operators de-stroy the same fact, they are mutex because they tryto consume the same resource, which is not possi-ble. Our algorithm takes advantage of this by col-oring the facts. Two facts with a common color aremutex because they result from the consumption ofa common resource. This marking allows to know iftwo facts need competitive resources to be produced.The two first steps of the algorithm are to determinethe number of colors per fact, and to create the initialcolors which will be used to create new color combi-nations. The creation of the first (primary) colors isdeduced from the “initial state” of the problem. Thus,we can give a (or several) different color to each factof the initial state because those facts are not perma-nent mutex between each other. Our algorithm thenpropagate the primary colors until all facts are col-ored. We do not detail the propagation process. Fromthe mutex relations between facts, we deduce the mu-tex relations between operators to compute the inter-action degrees.

Implementation details

In our planner, the user has to provide a splittinglevel. This is a percentage which determines howmany operators will beclass creators. Those oper-ators are then determined by thesplitting strategy.At each call of the heuristic function&, the algorithmneeds to assess sets of states. During the successivecalls, the algorithm may assess several times the sameset. To avoid this, we need to store intermediate valu-ations of sets obtained during& computations. A setof states is described byfacts: if � is the number of

facts of the problem, each set is described by a vec-tor ' � �� , where'�$ gives the truth value ofthe $�� fact. The vectors are stored in adecision tree(DT) where leaves contain the& intermediate valua-tions. Formally, we have�� . Thus,we can read and write intermediate values in a con-stant time hand coded strategy��. This mechanismallows us not to recompute& from scratch.If during & computation, the algorithm reaches abranch where it has to assess a set which is alreadybeing assessed at a lower depth, the branch will becut. To detect such branches, we also use a methodbased ondecision trees.

Figure 2: visited states for the gripper problem: in-stance with 6 balls

Thanks to those mechanisms, our planner behaveslike a dynamic programming algorithm when usedwith a full splitting. This allows to study a contin-uum between the resolution with a relaxed GraphPlanheuristic(no splitting)and with a dynamic program-ming approach. With the intermediate splitting lev-els, more or less constraints are taken into account inthe heuristic computation.

Results on the Gripper domain

We solved this problem with two splitting strate-gies: the automatic one, described above, and a handcoded one, in order to study the impact of the strat-egy. We tried a range of splitting percentages from0% (then the heuristic computation is equivalent toa relaxed GraphPlan) to 100%. As expected, thenumber of visited states decreases when the splittinglevel increases. Figure 2 shows the relation between



the splitting level and the number of visited statesfor both strategies. The automatic splitting strategy(dashed edge) is deduced from the pre-computed per-manent mutexes. The operators with the greatest in-teraction level are the“move” operators. As a re-sult, they are preferentially “class creators” (Figure1). Our hand-coded strategy does exactly the oppo-site: “pick” and “drop” operators are preferentiallyresponsible for splitting. The automatically deducedstrategy visits the search space in a more efficientway. This is due to the fact that when we do not splitonmoveoperators, we propagate a lot of incoherence,becausemoveoperators are very interactive and gen-erate numerous mutex relations.

Results on the Blocks World domain

This time, the automatic strategy is equivalent to arandom splittingbecause each operator has the sameinteraction degree. As a result, there is no prefer-entially chosen operator to be responsible for split-ting. By hand, we privileged the“pick” operators tobe responsible for splitting. The hand coded strat-egy is here the best one. This is because this strat-egy manages to capture-literals constraints betweenfacts with � � (mutexonly correspond to � �).

Figure 3: CPU time for the 5 blocks problem

Concerning overall CPU time, on a five blocks in-stance, we can see that the two extremes (relaxedGraphPlan and dynamic programming) give the bestresults (Figure 3). For a splitting level between 0%and 50%, the number of visited states decreases, butthe heuristic computation time increases: we do not

have any benefit from the splitting. From 50%, theoverall CPU time starts to decrease. This is due toour intermediate results storage. With such splittinglevels (50% to 100%), the heuristic becomes very in-formative. The search algorithm then focuses in onedirection. Therefore, previous stored results will bereused. With too small splitting levels, there are toomuch changes of direction for the intermediate stor-age to be used efficiently. We verified this intuitionempirically by studying the ratio� � number of el-ements read in the DT / number of elements storedin the DT. This ratio reflcts the utility of our storage.If � ( �, the storage mechanism is not very useful:there are less read elements than the total amount ofstored elements in the DT. If� ) �, there are moreread elements than the total amount of stored ele-ments in the DT. This means that we can avoid unnec-essary computations: some elements are read severaltimes in the DT, rather than being re-computed sev-eral times. For the 5 blocks problem,� remains lowerthan 1 up to 50%, it then slowly increases from 1 to 3for a 100% splitting.

Conclusion and Perspectives

We proposed and formalizedsearch space splitting.We presented its application to compute admissibleheuristics for optimal planning. Thesearch spacesplitting aims at increasing the quality of the heuris-tic. The more we split, the more the heuristic gives alength close to the reality. One of our future work isto optimize the splitting level in order to minimize theglobal complexity of the planning process: this levelis a parameter given by the user, and we are workingon how to deduce it automatically.We presented an automatic splitting strategy whichappears to be efficient (in terms of reducing the sizeof the search space) in the general case. However, theblocksworld example proves us the existence of bet-ter strategies in certain cases. We are working on away to automatically adapt the splitting strategy tothe domain. Our method is efficient with extremesplitting levels (close to 0 or 100) on small dimen-sion problems. With bigger dimensions, too small


splitting levels give a poor estimation, thus leadingthe search algorithm to make a too vast exploration.Our first experiments show that problems with highdimensions should be tackled with a high splittinglevel. Of course, we can not handle those problemswith a full splitting, because it would be equivalent tosolve them with a dynamic programming algorithm,which is not applicable with huge dimensions. Quitehigh splitting levels (60 to 90) could relax the prob-lem enough to break the complexity while giving aninformative heuristic. The search algorithm wouldthen concentrate its exploration on a few privilegeddirections, because it is well informed. But, this leadsto storage problems: there are too much intermediateresults to store in the DT. To handle this, we envisionusing tree reduction methods issued from the MultiTerminal Binary Decision Diagram domain.We expect those methods to help us dealing withtougher problems: the splitting provides a mean tocontrol the accuracy of the heuristic which could helpto explore greater search spaces in an efficient man-ner, or to deal with optimization criteria richer thanthe plan length (PDDL 2.1).

Bibliography

[1] Blum, A., and Furst, M. 1997. Fast planningthrough planning graph analysis.Artificial In-telligence90(1-2):281-300.

[2] Bonet, B., and Geffner, H. 1998. Hsp: Heuris-tic search planner. InPlanning Competition ofAIPS-98.

[3] Bonet, B., and Geffner, H. 1999. Planning asheuristic search: New results. InECP-99, 360-372.

[4] Bonet, B., and Geffner, H. 2001. Heuristicsearch planner 2.0.AI Magazine22(3):77-80.

[5] Bylander, T. 1994. The computational complex-ity of propositional STRIPS planning.ArtificialIntelligence69(1-2):165-204.

[6] Fox, M., and Long, D. 1998. The automatic in-ference of state invariants in tim. InJAIR, 367-421.

[7] Fox, M., and Long, D. 2000. Utilizing automat-ically inferred invariants in graph constructionand search. InAIPS-00, 102-111.

[8] Gerevini, A., and Schubert, L.K. 2000. Discov-ering state constraints in DISCOPLAN: Somenew results. InAAAI/IAAI, 761-767.

[9] Haslum, P., and Geffner, H. 2000. Admissi-ble heuristics for optimal planning. InAIPS-00,140-149.

[10] Hoffmann, J. 2001. FF: The fast-forward plan-ning system.AI Magazine22(3):57-62.

[11] Hoffmann, J. 2002. Local search topology inplanning benchmarks: A theoretical analysis. InAIPS-02.

[12] Kambhampati, S.; Parker, E.; and Lam-brecht, E. 1997. Understanding and extendinggraphplan. InECP-97, 260-272.

[13] Long, D., and Fox, M. 1999. Efficient imple-mentation of the plan graph in STAN.JAIR10:87-115.

[14] Meiller, Y., and Fabiani, P. 2001. Tokenplan; aplanner for both satisfaction and optimizationproblems.AI Magazine22(3):85-87.

[15] Nigenda, R.; Nguyen, X.; and Kambhampati, S.2000. Altalt: Combining the advantages ofgraphplan and heuristic state search. InKBCS-00.

[16] Rintanen, J. 1998. A planning algorithm notbased on directional search. InKR-98. 617-624.

[17] Rintanen, J. 2000. An iterative algorithm forsynthesizing invariants. InAAAI/IAAI, 806-811.

[18] Zemali, Y.; Fabiani, P.; and Ghallab, M. 2001.Using state space splitting to compute heuristicin planning. InPLANSIG-01.

Author Information

Yacine Zemali ONERA / DCSD – Centre deToulouse 2 avenue Edouard Belin BP 4025, 31055Toulouse cedex 4, [email protected] �


https://www.researchgate.net/publication/220605404_Tokenplan_A_Planner_for_Both_Satisfaction_and_Optimization_Problem?el=1_x_8&enrichId=rgreq-a0179853301e215269b1676089e12005-XXX&enrichSource=Y292ZXJQYWdlOzIyMTE1MzMwNjtBUzo5NzU2Mjg3NDg3NTkxN0AxNDAwMjcyMjEwNzgw



https://www.researchgate.net/publication/2755209_Efficient_Implementation_of_the_Plan_Graph_in_STAN?el=1_x_8&enrichId=rgreq-a0179853301e215269b1676089e12005-XXX&enrichSource=Y292ZXJQYWdlOzIyMTE1MzMwNjtBUzo5NzU2Mjg3NDg3NTkxN0AxNDAwMjcyMjEwNzgw



https://www.researchgate.net/publication/2875167_Understanding_and_Extending_Graphplan?el=1_x_8&enrichId=rgreq-a0179853301e215269b1676089e12005-XXX&enrichSource=Y292ZXJQYWdlOzIyMTE1MzMwNjtBUzo5NzU2Mjg3NDg3NTkxN0AxNDAwMjcyMjEwNzgw



https://www.researchgate.net/publication/2348445_Utilizing_Automatically_Inferred_Invariants_in_Graph_Construction_and_Search?el=1_x_8&enrichId=rgreq-a0179853301e215269b1676089e12005-XXX&enrichSource=Y292ZXJQYWdlOzIyMTE1MzMwNjtBUzo5NzU2Mjg3NDg3NTkxN0AxNDAwMjcyMjEwNzgw






https://www.researchgate.net/publication/2840582_Local_Search_Topology_in_Planning_Benchmarks_A_Theoretical_Analysis?el=1_x_8&enrichId=rgreq-a0179853301e215269b1676089e12005-XXX&enrichSource=Y292ZXJQYWdlOzIyMTE1MzMwNjtBUzo5NzU2Mjg3NDg3NTkxN0AxNDAwMjcyMjEwNzgw



https://www.researchgate.net/publication/220604711_FF_The_Fast-Forward_Planning_System?el=1_x_8&enrichId=rgreq-a0179853301e215269b1676089e12005-XXX&enrichSource=Y292ZXJQYWdlOzIyMTE1MzMwNjtBUzo5NzU2Mjg3NDg3NTkxN0AxNDAwMjcyMjEwNzgw

https://www.researchgate.net/publication/220604711_FF_The_Fast-Forward_Planning_System?el=1_x_8&enrichId=rgreq-a0179853301e215269b1676089e12005-XXX&enrichSource=Y292ZXJQYWdlOzIyMTE1MzMwNjtBUzo5NzU2Mjg3NDg3NTkxN0AxNDAwMjcyMjEwNzgw

https://www.researchgate.net/publication/228917086_Using_state_space_splitting_to_compute_heuristic_in_planning?el=1_x_8&enrichId=rgreq-a0179853301e215269b1676089e12005-XXX&enrichSource=Y292ZXJQYWdlOzIyMTE1MzMwNjtBUzo5NzU2Mjg3NDg3NTkxN0AxNDAwMjcyMjEwNzgw






https://www.researchgate.net/publication/2430520_AltAlt_Combining_the_Advantages_of_Graphplan_and_Heuristic_State_Search?el=1_x_8&enrichId=rgreq-a0179853301e215269b1676089e12005-XXX&enrichSource=Y292ZXJQYWdlOzIyMTE1MzMwNjtBUzo5NzU2Mjg3NDg3NTkxN0AxNDAwMjcyMjEwNzgw














https://www.researchgate.net/publication/221393330_A_Planning_Algorithm_not_based_on_Directional_Search?el=1_x_8&enrichId=rgreq-a0179853301e215269b1676089e12005-XXX&enrichSource=Y292ZXJQYWdlOzIyMTE1MzMwNjtBUzo5NzU2Mjg3NDg3NTkxN0AxNDAwMjcyMjEwNzgw

https://www.researchgate.net/publication/221393330_A_Planning_Algorithm_not_based_on_Directional_Search?el=1_x_8&enrichId=rgreq-a0179853301e215269b1676089e12005-XXX&enrichSource=Y292ZXJQYWdlOzIyMTE1MzMwNjtBUzo5NzU2Mjg3NDg3NTkxN0AxNDAwMjcyMjEwNzgw

https://www.researchgate.net/publication/220836336_Planning_as_Heuristic_Search_New_Results?el=1_x_8&enrichId=rgreq-a0179853301e215269b1676089e12005-XXX&enrichSource=Y292ZXJQYWdlOzIyMTE1MzMwNjtBUzo5NzU2Mjg3NDg3NTkxN0AxNDAwMjcyMjEwNzgw



https://www.researchgate.net/publication/236344199_HSP_Heuristic_Search_Planner?el=1_x_8&enrichId=rgreq-a0179853301e215269b1676089e12005-XXX&enrichSource=Y292ZXJQYWdlOzIyMTE1MzMwNjtBUzo5NzU2Mjg3NDg3NTkxN0AxNDAwMjcyMjEwNzgw




ARTICLE

Managing Temporal Information for Durative Actions in LPG

Author: A. Saetti, A. Gerevini, and I. Serina

Introduction

Local search is emerging as a powerful method fordomain-independent planning (e.g., [3, 7]). In [6] wehave described the use of local search in the spaceof linear action graphs(LA-graphs), particular sub-graphs of the planning graph representation [1]. Inthis paper we present some extensions to handle plan-ning domains specified in the recentPDDL2.1 lan-guage supporting “durative actions” [2] . In partic-ular, we introduce a plan representation calledtem-poral durative action graph(TDA-graph) that is cur-rently used byLPG to handle durative actions and thetemporal information associated with them.Like traditional planning graphs, TDA-graphs are di-rected acyclic “levelled” graphs with two kinds ofnodes (action nodes and fact nodes). Moreover, inTDA-graphs action nodes are marked with tempo-ral values estimating the earliest time when the cor-responding actions terminate. Similarly, fact nodesare marked with temporal values estimating the earli-est time when the corresponding facts become true.Finally, a set of ordering constraints is maintainedduring search to handle mutually exclusive actions(called mutexactions), and to take account of the“causal” relations in the current plan.LPG is an incremental planner based on stochastic lo-cal search that can compute a succession of plans,each of which improves the quality of the previousones according to a plan metrics specified in the plan-ning domain. In the 3rd International Planning Com-petition (IPC) [8] our planner showed excellent per-formance on a large set of problems, in terms of bothspeed to compute the first solution and quality of thebest solution that can be computed by the incrementalprocess.This paper is organized as follows. Second sectionpresents the TDA-graph plan representation; thirdsection describes the different types of ordering con-

straints used byLPG, how they are stated by the plan-ner, and how they are used to compute the temporalvalues associated with the actions of the plan; fourthsection gives the results of an experimental analysiswith some domains used in the 3rd IPC; finally, fifthsection gives our conclusions.

Plan Representation

In simple STRIPS domains the last version ofLPG

uses a particular subset of the action graphs, calledlinear action graphs[6].LPG can handle levels 2 and 3 ofPDDL2.1. Level2 introduces numerical quantities and level 3 a newmodel of actions, calleddurative actions, that sup-ports stronger parallelism among the actions in theplan obtained by distinguishing different ways inwhich they can overlap [2].In simpleSTRIPSdomains, the additive effects of anaction� at a level are represented by fact nodes atthe level � �, and its preconditions by fact nodesat the level. For PDDL2.1 domains involving du-rative actions, in order to represent the facts that be-come true after the beginning of the action�, LPG

uses no-op nodes to represent the state of the worldduring the execution of an action. Theatstart ad-ditive/delete effects of� at level,��/��,are achieved after the beginning of�, and soLPG

introduces/removes the corresponding no-op nodesat level of . The atend additive/delete effectsof �, ��/��, are achieved at the endof �, and so they do not affect any no-op node atlevel ; LPG introduces/removes the fact nodes of��/�� at level�� of . Theatstartconditions of�, ��, must be achieved at thebeginning of�, and soLPG verifies that the corre-sponding fact nodes at level are supported in.Theoverall conditions of�, ��, must beachieved during the full duration of the execution of





�, and soLPG verifies that the corresponding no-opnodes are supported at level. Theatend conditionsof �, ��, must be true at the end of�; moreprecisely, they must be achieved after theatstart

effects become true and before theatend effects be-come true. Therefore, as for theoverall condi-tions, LPG checks that the no-op nodes correspond-ing to theatend conditions are supported at level.The difference betweenoverall andatend con-ditions consists in a different temporal management.This additional way of using the no-op nodes in ac-tion graphs leads to the definition of a new class ofaction graphs calleddurative action graphs.

Definition 1 A durative action graph (DA-graph)for � is a linear subgraph of � such that, if� isan action node of� in at level, then

� the fact nodes corresponding to theatstartconditions of� are in at level,

� the fact nodes corresponding to theatend effectsof � are in at level � �,

� the no-op nodes corresponding to theoverallconditions of�, theatend conditions of�, andtheatstart effects of� are in at level,

� all edges connecting the nodes of the previousitems to� are in.

LPG represents durative actions by modifying theoriginal structure of the planning graph�, i.e., by in-troducing edges from action nodes to no-op nodes atthe same level of the graph to representatstart ef-fects, and edges from no-op nodes to action nodes torepresentatend andoverall conditions.In order to represent the temporal information asso-ciated with the end points of an action, our planner(i) assigns real values to action, fact and no-op nodesof the DA-graph, and (ii) uses a set� of orderingconstraints between action nodes. The value associ-ated with a fact or no-op node# represents the (esti-mated) earliest time at which# becomes true, whilethe value associated with an action node� representsthe (estimated) earliest time when the execution of�can terminate.

This assignment of real values to the durative actiongraph nodes leads to the representation used byLPG

to handle durative actions calledtemporal durativeaction graph.

Definition 2 A temporal durative action graph(TDA-graph) of� is a triple �� where isa durative action graph;� is an assignment of realvalues to the fact, no-op and action nodes of; � is aset of ordering constraints between the action nodesof.

Temporal Management for DurativeActions

In this section we discuss different types of orderingconstraints in the set� of TDA-graphs. Moreover,we describe how and when the temporal values of�are computed.

Figure 1: Types of ordering constraints between du-rative actions.

Ordering Constraints

The original planning graph representation [1] im-poses the global constraint that, for any action� atany level of the graph, every action at the followinglevel starts after the end of�. However, this can im-pose some unnecessary ordering constraint betweenactions of different levels which could limit actionparallelism in the plan (and hence its quality in termsof makespan). TDA-graphs support a more flexi-ble representation by handling ordering constraintsexplicitly: actions are ordered only through the or-dering constraints in� that are stated by the plan-ner during search. At each step of the searchLPG



adds/removes an action� to/from the current TDA-graph. When� is added,LPG generates (i) appropri-ate ”causal links” between� and other actions withpreconditions achieved by�, (ii) ordering constraintsbetween� and every action in the TDA-graph that ismutex with� [6].For simple traditional domains where every conditionis of typeoverall and any effect is of typeatend,the ordering constraints in� are of two types: con-straints between actions that are implicitly ordered bythe causal structure of the plan (��-constraints), andconstraints imposed by the planner to deal with mu-tually exclusive actions (��-constraints). � �� belongs to� if and only if � is used to achieve a con-dition node of� in , while � �� (or � �� )belongs to� only if � and� are mutually exclusivein . If � and� are mutex actions, the planner ap-propriately imposes either� �� or � �� . LPG

chooses� �� if the level of� precedes the level of�, � �� otherwise. Under this assumption on the“direction” in which��-constraintsare imposed, itis easy to see that the levels of the graph correspondto a topological order of the actions in the representedplan satisfying every ordering constraint in�. An or-dering constraint� � � in � (where “�” stands for�� or ��) states that the beginning of� comes af-ter the end of�. Our planner schedules actions in away that the execution of an action is anticipated assoon as possible; and so� � �, means that� startsimmediately after the end of�.For more complex domains, where operators cancontain all types of conditions and effects for a dura-tive action,LPG distinguishes some additional typesof ordering constraints in�. In fact, two ordered ac-tions�, � can overlap in four different ways, depend-ing on the type of conditions and effects involved inthe casual relation between� and �, or in the mu-tex relation between them. The four orderings con-straint different pairs of end points of the intervalsassociated at the duration of the actions. We indicatethese constraints with

��

� ,��

� ,��

� and��

� (there is afifth possible ordering constraint between two dura-tive actions� and�; e.g., if �*�� ) �*��, it ispossible that� supports anatend condition of� and

� supports or deletes anatstart condition of�; but

currentlyLPG does not consider this case).��

� � be-longs to� if � �� or � �� and� can-not start before the end of� (see case� of figure 1).

��

� � belongs to� if � �� or � �� and� cannot end before the end of� (see case� offigure 1). �

��

� � belongs to� if � �� or� �� and� cannot start before the beginning

of � (see case� of figure 1). ��

� � belongs to� if� �� or � �� and� cannot end beforethe beginning of� (see case� of figure 1).

In general, if� � �, there is at least one ordering

constraint in� between� and� of type��

� ,��

� ,��

� ,

or��

�. If there is more than one ordering constraintbetween� and�, it is possible to simplify� by re-moving all them from�, except the strongest one,i.e., the constraint for which the execution of� is themost delayed one.

The strongest constraint is��

� , because��

� � im-poses that the execution of� cannot overlap the exe-cution of�, i.e.,� cannot start before the end of�. Theweakest constraint is

��

� , because��

� � imposes that� ends after the beginning of�; so,� can start beforethe beginning of�. Note that the strongest constraint

between��

� and��

� depends on the durations of theactions involved. In particular, if the duration of� is

longer than the duration of�, then��

� is stronger than��

� ; if the duration of� is shorter than the duration of�, then

��

� is stronger than��

�. If � and � have the

same duration, the constraint��

� is as strong as��

� .Finally, when the duration of at least one of the ac-tions involved depends on the particular state of the

world � in which the action is applied, if��

� � ��

but � ��

�,��

�� , then both��

� � and��

� �must be kept in� and evaluated at “runtime”. This isbecause the state� is only partially defined in the cur-rent partial plan, and it could change when the plan ismodified.



Temporal Values of TDA-graph Nodes

The constraints stored in� are useful to compute thetemporal values of the nodes in a TDA-graph. Thesevalues are updated each time an action node is addedor removed, which in the worst case requires lineartime with respect to the number of nodes in the graph[6]. We denote with� $+� � the temporal value as-signed by� to a node . In domains where all ef-fects are of typeatend and all conditions of typeoverall, LPG computes the temporal value of anaction � by simply examining the maximum valuesover the temporal values of the actions� in thatmust precede� according to�:

� ��

��

� ��

LPG introduces a positive, quantity to satisfy the or-dering constraints. Without this term the beginning of� would be equal to the end of an action� that mustprecede�.If there is no action node that must precede� accord-ing to�, then� cannot start before zero; so,� $+��is set to the duration of�. In order to give a better es-timate of the temporal value at which an action termi-nates, if a condition is not supported, instead of zero,LPG estimates the earliest temporal value at whichthe corresponding proposition becomes true, as de-scribed in [6]. For more general TDA-graphs sup-porting every type of conditions/effects previouslydescribed, the definition of� $+�� is more complexbecause it takes into account all the types of orderingconstraints previously introduced:� $+��

��

��

��

� ��

��

��

��

� ��

��

��

� ��

��

��

��

� ��

��

��

� ��

The term into square brackets represents the earliesttemporal value at which the execution of� can start,in accordance with the ordering constraints of type��

� ,��

� ,��

� and��

� involving � that are present in thecurrent TDA-graph.

0.001: (TURN_TO SAT0 STATION2 PHEN6)[5.000]0.002: (SWITCH_ON INSTR0 SAT0)[2.000]5.003: (CALIBRATE SAT0 INSTR0 STATION2)[5.000]5.004: (TURN_TO SAT0 PHEN4 STATION2)[5.000]10.005: (TAKE_IMAGE SAT0 PHEN4 INSTR0 THRGRP0)[7.000]17.006: (TURN_TO SAT0 PHEN6 PHEN4)[5.000]22.007: (TAKE_IMAGE SAT PHEN6 INSTR0 THRGRP0)[7.000]29.008: (TURN_TO SAT0 STAR5 PHEN6)[5.000]34.009: (TAKE_IMAGE SAT0 STAR5 INSTR0 THRGRP)[7.000]

Figure 2: Example of a simple plan in the “Satellite” do-main (“SimpleTime” variant) of the 3rd IPC.Numbers in brackets are action durations. Thenumber before the action indicates its start time.

The temporal values of the action nodes are used tocompute the temporal values of the fact and no-opnodes. If a fact# is supported by more actions,LPGconsiders the temporal value of the action that sup-ports# earlier. If all conditions are of typeoveralland all effects of typeatend, LPG computes the tem-poral value of a fact node# by simply examining theminimum values over the temporal values of the ac-tions� in that support# :

� ��

��

��

where��#� is the set of action nodes that supportthe fact node# . More in general,LPG distinguishesthe cases in which# is supported at the beginning orat the end of an action, and so the temporal value ofa fact node# is computed according to the followingmore complex definition of� $+�#�:

� ��

��

��

��

��

��

��

��

where��#� and��#� are the sets of action nodesthat support# at the end and at the beginning, respec-tively, of the corresponding actions.In planning problems where it is important to mini-mize the makespan of the plan,LPG uses these tem-poral values to guide the search toward a directionthat improves the quality of the plan under construc-tion. In particular, they are used to estimate the tem-poral value at which a condition not supported couldbecome supported [5].






Figure 3:Performance of TDA-graphs compared with TA-graphs and the SuperPlanner in Satellite, SimpleTime. Onthe x-axis we have the problem names indicated with numbers. On the y-axis (log scale), we have theCPU-time (left) and the quality of the plans measured using the makespan of the plan (right).

Experimental Results

In this section we present some experimental resultsillustrating the efficiency ofLPG in the domains in-volving durative actions that were used in the 3rd IPC(i.e., “SimpleTime”, “Time” and “Complex”).1

The results ofLPG correspond to median values overfive runs for each problem considered. The CPU-timelimit for each run was 5 minutes, after which the ter-mination was forced.2

In order to verify the advantage of distinguishing dif-ferent types of�� and�� constraints, we comparedtwo versions ofLPG: a version using TDA-graphswith all types of ordering constraints, and a simplerversion in which every pair of actions can be ordered

using only constraints of type��

� (both for�� and�� constraints). While this is a sound way of order-ing actions, as discussed in the previous section, itcan over-constrain the temporal order of two actionsrelated by a causal or mutex relation. In the rest of thepaper the simpler temporal plan representation willbe denoted by a TA-graph (instead of a TDA-graph).As test domains we used the version SimpleTime

of Satellite, a domain used in the 3rd IPC. In thisdomain a “turn to” action might be mutex witha “calibrate” action, because the first has theatstart effect(pointing ?s ?d new) deny-ing an atstart condition of the second. For in-stance, in the TDA-graph representation there is

an��

��-constraintbetween the(calibrate sat0

instr0 station2) and (turn to sat0 phen4

station2) because theatstart effect (not

(pointing sat0 station2)) of the turn to

action denies theatstart condition (pointing

sat0 station2) of thecalibrate action. There-fore, in the TDA-graph representation the satellitescan turn immediately after the beginning of the cal-ibration of their instruments, while in the TA-graphrepresentation the satellites can turn only at the endof the calibration, because all mutex actions areordered by constraints of type

��

��. As a conse-quence, by using TDA-graphsLPG can find plansof better quality, i.e., of shorter makespan. Figure2 shows a plan found byLPG containing the ac-tions discussed above. Note that(turn to sat0

1The system is available athttp://prometeo.ing.unibs.it/lpg. For a description of these domains and of the rel-ative variants the reader may see the official web site of the 3rd IPC (www.dur.ac.uk/d.p.long/competition.html). Detailed results for all the problem tested are available at the web site ofLPG.

2The tests ofLPG were conducted on a PIII Intel 866 Mhz with 512 Mbytes of RAM. As described in [4] and [5],LPG is anincremental, anytime planner producing a succession of plans, each of which improves the quality of the previous plans.


phen4 station2) starts at time��, because ofthe use of

��

�� constraint betweencalibrate andturn to. If we used a (stronger)��-constraint,turn to would have to start after time��, lead-ing to a plan longer by five time units. Althoughthe overlapping of the mutex actions previously illus-trated is the only possible one in the Satellite domain,the duration of the plans generated byLPG usingTDA-graphs is on average 10% shorter than the du-ration of the plans generated using TA-graphs. More-over, in terms of CPU-time the overhead incurred byhandling TDA-graphs instead of TA-graphs was neg-ligible (see Figure 3).

Table 1:Summary of the comparison ofLPG1.1 and Su-perPlanner in terms of: number of problemssolved byLPG (2nd column) and the SuperPlan-ner (in brackets); problems in whichLPG-speedis faster/slower (3rd/5th columns); problems inwhich LPG-quality computes better/worse solu-tions (4th/6th columns).

In order to derive some general results on the per-formance of our planner with respect to all the otherplanners of the 3rd IPC, we compared the results ofthe last version of our planner with the best resultsover all the other fully automated planners in termsof CPU-time and plan quality. We will indicate thesecond results as if they were produced by an hypo-thetical “SuperPlanner” (note, however, that such aplanner does not exist).3

The performance ofLPG was tested in terms of bothCPU-time required to find a solution (LPG-speed) and

quality of the best plan computed, using at most 5minutes of CPU-time (LPG-quality). The overall re-sults are showed in table 1.LPG-speed is generallyfaster than the SuperPlanner, and it always solves alarger number of problems. Overall, the percentageof the problems solved byLPG is 98.7%, while thosesolved by the SuperPlanner is 75%. The percent-age of the problems in which our planner is fasteris 87.5%, while this percentage for the SuperPlan-ner is 10.2%. ConcerningLPG-quality, the percent-age of the problems for which our planner produceda better quality solution is 94.6%, while this percent-age for the SuperPlanner is only 5.4%. In particularLPG finds a solution with a quality which is consid-erably better (at least 50%) in 35.7% of the problemsfor which bothLPG and SuperPlanner find a solution(with some significant differences in Satellite), whilethe SuperPlanner never finds a solution with qualityconsiderably better thanLPG.

Conclusions and Future Works

We have presented a new plan representation support-ing durative actions, as well as some techniques formanaging temporal information associated with factsand actions in a temporal plan. These techniques arefully implemented and integrated in the current ver-sion of LPG. As shown by the experimental resultspresented in this paper, the use of the TDA-graph rep-resentation in our planner supports the generation ofvery high quality plans, which in general are betterthan the plans computed by the other fully-automatedplanners that took part in the competition.Our current temporal representation cannot deal witha particular case of action overlapping. This casecan arise in domains where actions can be plannedone during the other because of a particular combi-nation of different types of preconditions and effects.For instance, consider two actions� and� such that�*�� ) �*��. In principle, it can be possiblethat � supports anatend condition of � though an

3The tests of SuperPlanner were conducted on the official machine of the competition, an AMD Athlon(tm) MP 1800+ (1500Mhz)with 1 Gbytes of RAM, which is slightly faster than the machine used to test the last version ofLPG.



atend effect, and that� supports anatstart con-dition of � though anatstart effect. However, if�has a precondition that is supported (only) by�, ourplanner cannot generate a plan in which� is used tosupport a precondition of�. Future work includes anextension of TDA-graphs to handle this case.

Bibliography

[1] Blum, A., and Furst, M. 1997. Fast planningthrough planning graph analysis.Artificial In-telligence90:281-300.

[2] Fox, M., and Long, D. 2001. PDDL2.1: An ex-tension to PDDL for expressing temporal plan-ning domain. http://www.dur.ac.uk/d.p.long/competition.html

[3] Gerevini, A., and Serina, I. 1999. Fast planningthrough greedy action graphs. InProc. of AAAI-99.

[4] Gerevini, A., and Serina, I. 2002.LPG: A plan-ner based on local search for planning graphswith action costs. InProc. of AIPS-02.

[5] Gerevini, A., Serina, I., Saetti A., Spinoni S.2003. Local Search for Temporal Planning inLPG. In Proc. of ICAPS-03.

[6] Gerevini, A., Saetti, A. and Serina, I. 2003.Planning through Stochastic Local Search andTemporal Action Graphs. InJAIR(to appear).

[7] Hoffmann, J., and Nebel, B. 2001. The FFplanning system: Fast plan generation throughheuristic search.JAIR14:253-302.

[8] Long, D, and Fox, M. 2003. The 3rd Interna-tional Planning Competition: Results and Anal-ysis. InJournal Artificial Intelligence Research(to appear).

Author Information

Alessandro Saetti, Alfonso Gerevini, andIvan Serina Dipartimento di Elettronica perl’Automazione, Universit`a degli Studi di Brescia,Via Branze 38, I-25123 Brescia, Italy{saetti,gerevini,serina}@ing.unibs.it

�

ARTICLE

The PLANFORM - KATool

Author: C. Doniat

Abstract

PLANFORM-KATool (KATool in short) is an intel-ligent system [1] that embodies work aimed at al-lowing domain experts to generate a domain modelfor an AI planning system, carried out as part ofa larger project to build an integrated set of toolsfor supporting AI planning. This article outlinesthe overall methodology and describes how KA-Tool supports it by a demonstration with the ex-perimental tool. A Domain model is generated inwhich can be represented by cluster of constraintsshaping an Ontology of each studied case. Newprogress has been made towards automatic conver-sion into the modelling language OCL and integra-tion with the OCL tool GIPO.

Introduction and motivation

KATool research concerns the very difficult area ofKnowledge Acquisitionfor planning application, us-ing an approach inspired by theknowledge-based sys-tem (KBS) community. This project is an experi-mental user interface as part ofPLANFORM project.It aims to support the expert domain (e.g. non AIplanning and AI planning expert) during the knowl-edge acquisition process with some mixed surrogatelike Question-driven process, Ontological engineer-ing & Ontology Libraries (e.g. robot positioning),Annoted Knowledge sets (e.g. wildcards)andFrame-based representations. The final target is being a do-


main model inOCL (an object-oriented sorted first-order logic language) as part of GIPO. This last maybe also translated intoPDDL under GIPO. KATool isunder development in Java language.

Knowledge acquisition process

Briefly, the knowledge acquisition (KA) process em-bodied in the KA-Tool can be seen in Figure 1. AQuestion-driven processworks on protocols and ona skeleton theory derived from an ontologies library.By protocolwe mean raw domain knowledge – tran-scripts, documents, interviews, observations (we willuse the term ’transcript’ hereafter for the combinationof transcripts, documents, interviews, observations asa whole), created by aproblem-solvingepisode inwhich experts are provided with a real-AI Planningproblem, of the kind that they normally deal with,and are asked to solve it. As they do so, they are re-quired to describe each step, and their reasons for do-ing what they do. The transcript of their verbal and/ortext account is, in this case, called aprotocol.

Figure 1: Knowledge acquisition process

By problem specificationwe mean a definition or de-scription of an application domain represented as aset of choices at a particular level of abstraction inan ontological hierarchy. Thus ’Hiking’ and ’Drum-store’, the simple logistics domains used for our ex-periments reported in [2], are problem specifications.The second stage in the KA process incorporates atheory revision processwhich produces a concep-tual model using a hierarchical frame system whichallows easy representation of inheritance betweenframes(the relationshipkind-of) and/or aggregation

between frames (the relationshippart-of) for in-stance. Translation into a sorted first-order logicsuch as that used by OCL is straightforward. Frameshave an advantage over a first-order logic in thatboth structure and behaviour can be embodied in onegeneric entity. An Ontology is defined as a rigorousspecification of a set of specialised vocabulary termssufficient to describe and reason about the range ofsituations of interest in a particular domain – a con-ceptual representation of the domain entities, events,and relationships. Two primary relationships of inter-est are abstraction (kind-of) and composition (part-of). Thus an Ontology provides a grounding of thekey concepts within a domain. In principle we needboth an Ontology of planning problem domains andof planning software to carry out knowledge acqui-sition since the premise is that the conceptual frame-work of the problem domain is not the same as thatof the planning software – otherwise there would belittle problem for the domain expert.TheQuestion-driven processis also used to constructadomain dictionary, in effect a partial Ontology – us-ing the experimental approach, it is hard to make anexhaustive analysis of all domain objects. Neverthe-less, theproblem specificationcan be used to definerelevant objects and relationships, using macroscopicproperties that support appropriate choices. Thedo-main dictionaryis associated with (i) a particular do-main, (ii) specification of a problem or problems thatwe want to solve, (iii) the reasoning that belongs tothe studied domain and allows the specified problemto be solved. The final stage is theenrichment pro-cess, which adds with someOntological engineeringtechniquesthe new partial Ontology into the existingOntologies library.

Architecture

Figure 2 shows the main architecture of thePLAN-FORM KA-Tool – an intelligent system that containsthe KA process. The user applies themodule of do-main model buildingto a particularproblem speci-fication. The building of a newconceptual modelmight be carried out with or without an existing



problem specificationfrom theDomain model library(Ontology). The result is recorded in this library. Onthe right-hand side, the overall knowledge base con-sists of theconceptual modelof the knowledge acqui-sition process itself, calledPLANFORM-KA and theKA-Expertisebelonging to the particular conceptualmodel being constructed.

Figure 2: Architecture of the KATool

Methodology and process cycle

We presented two case studies using our methodol-ogy, based on the problem specifications: (i) ’Drum-store: a logistics problem in a nuclear waste fac-tory with eight identical robots loading and unload-ing drums of nuclear waste materials’ and (ii) Hik-ing: another logistics problem for a ride of two peo-ple around Lake District in North of England.The PLANFORM toolkit as a whole has been used tocreate a domain model within which a number of spe-cific tasks can be planned. Thus the experiment didnot start with a specific task, but with the genericproblem specification. Subjects were asked to ex-plore the generic domain model that would be neededto plan within the domain of the problem specifica-tion and to support the solving of a number of specifictasks. Note that a more abstract version of this prob-lem would be to replace ’your lab’ with ’a lab’ wherethis might be anywhere in the world potentially. Aninstance of a specific task would be something like

’Professor Stein from DFKI Germany is to be enter-tained on Saturday May 9th’.Broadly, the following phases have been carried outin a process cycle so to build with aninduction by ex-ample algorithma domain model for both case stud-ies. The definitions and details of these steps are de-scribed in [2]. Meanwhile these phases, the systemmay ask the domain expert to avoid some ambigui-ties and it uses in parallel Ontologies libraries as well,that provides a sufficient common grounding for ap-plications.

Phase 1: building of domain dictionariesthat puttogether a set of terms according to the prob-lem specification and scenarios that each expertdefines reasoning strategies to solve the problemspecification. This phase gave some statistics (i.e.annoted knowledge set) on terms and their usingin the scenarios. We drawn a specific annotedknowledge set called CDDC (Checking DomainDictionary Cover) that has been used in the nextphase. Additional details are available in [3].

Phase 2: building of conceptual and epistemologi-cal modelthat provided a conceptual model con-taining semantic relationships, objects and ac-tions. We then add an epistemological model – thedefinition of concepts, hierarchy and structuringrelationships (behaviours). This phase was a gen-eralization process that took different elements asinputs from the phase 1 (i.e. terms, scenarios andCDDC, even some wildcards as that is explainedin [3].

Phase 3: building the domain model in OCLthatprovided an automated translation from frame-based representations to sorted first-order logic.

Demonstrator and capture session

A first demonstrator has been implemented to val-idate the approach ofPLANFORM-KA. The follow-ing Figure 3 shows the main GUI during the creationof the Robot generic concept in theDrumstore


domain model. The core of the GUI is theAssis-tant Prompt(top, right hand side of Fig. 3), whichis the questioning system based around theAgent-Object-Task concepts. Meanwhile, theOntologyExplorer (top, left hand side of Fig. 3) gives a viewof the existing library so that it supports the Domainexpert. After a typical session, theProblem Specifi-cation Level(bottom of Fig. 3) puts together the spe-cialized knowledge representations as models. Oneof these models is the generated logical model seenin [3] Appendix 1 with OCL semantics and syntaxthrough a first version of a translator.

Figure 3: Capture session in KATool

Project information

This website is dedicated at KATool project:http://tech-cico.utt.fr/katool/. You will findout several information like a slideshow, manual anda getting start as well as the publications given in ref-erence as follows:

Bibliography

[1] Doniat, C., The PLANFORM-KA Tool.PLANET Newsletter issue 3. pp 7-9.

[2] Aylett, R., and Doniat, C., KATool and do-main contruction for planning applications.ES2002: 22nd SGAI International Conferenceon Knowledge-Based Systems and Applied Ar-tificial Intelligence. Cambridge. 10th-12th Dec.2002.

[3] Doniat, C., and Aylett, R., A Representationof Usage in KATool. 21th Workshop of theUK Planning and Scheduling Special InterestGroup. Delft University of Technology, TheNetherlands. Nov. 2002.

Author Information

Dr. Christophe Doniat Technical University ofTroyes, Tech-CICO Lab, [email protected] �



REPORT

The ICAPS 2003 Conference

Author: J. Hertzberg

As the AI planning and scheduling community andthe rest of the world are by now hopefully aware,two successful international conference series havebeen merged into one: The European Conferenceon Planning (ECP) and the International Conferenceon Artificial Intelligence Planning and Scheduling(AIPS), which had run alternately every other yearsince 1991. The result of the friendly merger is calledInternational Conference on Automated Planning andScheduling (ICAPS), and the first specimen could bevisited this June in Trento. To emphasize the conti-nuity of its AIPS and ECP roots, the official count-ing has this first ICAPS as the thirteenth, insertingto the count six AIPSes and six ECPs (the first ofwhich were called EWSPs, to add a little variety onacronyms).Let’s start with the stat stuff. ICAPS 2003 had 181registered participants. Of those, 34 had support fromthe Doctoral Consortium, which was an invention forthis conference that will live on in some way or theother in the ones to come. Additionally, 21 studentswere supported by the student program. 30 paperswere accepted out of 98 submitted. So, in terms offigures, ICAPS has continued the nice trend set by theprevious ECP and AIPS events. The financial supportwas largely made possible by generous sponsors, ofwhich PLANET and NASA deserve mentioning inparticular. Thanks to these organizations and to the

involved humans in flesh and blood behind them.Who if not the planning and scheduling peopleshould be able to plan and schedule a conferencewell? Sure, but it still remains a whole lot ofwork, as I can tell. The Conference Chairs, EnricoGiunchiglia, Nicola Muscettola, and Dana Nau, did agreat job, and I would like to add Piergiorgio Bertolias the representative of the local organization teamto the persons who have deserved our thanks. Whatwould you ideally expect as the frame of a high-levelscientific conference in Italy? Probably, excellentfood, azure skies, receptions in palazzi, a culture pro-gram and speeches making clear that this conferenceis a logical consequence of a history clearly goingback to ancient Roman times. They provided it all.They even exaggerated a bit on the azure skies.The proceedings Preface mentions that, compared toprevious years, some emphasis is on papers dealingwith planning under uncertainty and incomplete in-formation. I partially agree. However, my subjectiveview of this part of the program as a person work-ing in plan-based control of robots, is that this areawas only represented somewhat one-eyedly. Lookingat the proceedings, there is one section on the topic,and the papers, although undoubtedly of perfect qual-ity, are presenting frameworks or theoretical results.The satellite events did comprise a workshop and atutorial on the topic. But all this has left me largelyunsatisfied as to what sort of plan generation or us-age of plans would practically be needed or usefulunder uncertainty, at least for a robot, and the lackof satisfaction was not resolved by the workshop onPlan Execution. The invited talk by Malik Ghallab onsome of the pioneering LAAS work on Plan-BasedRobot Control stated the problem nicely and consis-tent with my own experience, but it made only moreobvious the gap to the rest of the program. If plan-ning and scheduling is supposed to be of practicaluse for robot control, we need to do something about


it – that was one of my main impressions from theconference. Luckily, ICAPS 2004 has declared theywant to put particular emphasis on the topic, and I amlooking forward to it.Another point of the Preface is undoubtedly true: apeak of papers on temporal planning and scheduling.Three out of eight Sections in the proceedings are onthese topics, plus half of the papers in the Applica-tion section. Looks we finally managed to have theconference series on planning and scheduling, ratherthan on planning alone. Both my non-representativeparticipants’ sample from coffee break chats and myconference dinner table round seemed to agree thatwe did not notice some wildly new and exciting tech-nical issue in the technical papers. (Then the dis-cussions tended to shift away to the question whetherwe ever had this feeling at other conferences, and,if so, whether we were right in retrospect. . . ) So,if you miss reading the ICAPS-03 Proceedings, youwon’t be completely lost at the next planning con-ference. However, we also agreed that there are asubstantial number of excellent, high quality paperswithin previously established lines of work, and theymake the proceedings definitely worth reading. Iliked much the session on planning and control, butthat may be due to my obsession with robots. Any-way, it included the paper by Nikovski and Brandon Decision-Theoretic Group Elevator Scheduling,which received the Best Applied Research Paperaward. The Best Basic Research Paper award went toFox and Long for their paper on Exploiting a Graph-plan Framework in Temporal Planning.Unrepresented in the proceedings, as usual, are thethree invited talks by Subbarao Kambhampati, Ma-lik Ghallab, and Douglas Smith, which is a pity.Kambhampati’s talk on ”1001 Ways to Skin a Plan-ning Graph for Heuristic Fun and Profit” (in fact,he went down to 987 ways) provided a witful tourd’horizon of ways in planning graph algorithms tocontrol search for different planner varieties and fordifferent planning problems. As far as I know,no paper is available, but the slides are acces-

sible underhttp://rakaposhi.eas.asu.edu/icaps-invited-talk.ppt. Malik Ghallab’s talkabout Plan-Based Robot Control was mentioned al-ready. I am not aware of a public version of it.The invited talk on Automated Synthesis of High-Performance Planners and Schedulers by DouglasSmith was the most interesting of the three to me,simply because I was less aware of that work than ofthe other two. The excuse is that, as he mentionedin the talk and as can be verified in his on-line pub-lication list, Douglas Smith has obviously seen hisown work mostly in teh tradition of program syn-thesis rather than planning, and went to the accord-ing conferences and journals. As the title suggests,the point of the work is to generate special-purposeplanners and schedulers rather than plans and sched-ules, based on a specification of some domain, whichcan then be run efficiently on problem instances fromthe domain. An on-line paper close to the talk canbe downloaded fromftp://ftp.kestrel.edu/pub/papers/smith/ase.pdf, and I recommendto read it in addition to the ICAPS proceedings.Next ICAPS will be on June 3-7, 2004, in Whistler,BC, Canada. Yes, ICAPS was faster to find theplace than the Olympic Committee! They will in-vite the youth of the world only in 2006 to cometo the Winter Games in 2010. ICAPS invites younow to come already next year, to do so in summer,and to probably take a look athttp://icaps04.icaps-conference.org/ first.Reference E. Giunchiglia, N. Muscettola, D. Nau(eds.): ICAPS 2003. Proceedings of the ThirteenthInternational Conference on Automated Planning andScheduling. AAAI Press (Menlo Park), 2003, ISBN1-57735-187-8

Author Information

Joachim Hertzberg Fraunhofer Institute for Au-tonomous Intelligent Systems (AIS), Schloss Bir-linghoven, D-53754 Sankt Augustin, [email protected] �



ANNOUNCEMENT

ICAPS 2004

�


INFORMATION

Member List for PLANET

Currently,PLANET has 68 nodes from 18 Europeancountries. Sites and contact persons are:

Austria- XIMES GmbH, Johannes Gärtner,[email protected]

Belgium- Robonetics NV, Filip Verhaeghe,[email protected]

- Space Applications Services (SAS), RichardAked,[email protected]

Bulgaria- Institute for Information Theories and Appli-

cations (FOI ITHEA), Krassimir Markov, [email protected]

Cyprus- University of Cyprus, Yannis Dimopoulos,[email protected]

Czech Republic- Charles University, Praha, Roman Barták,[email protected]

France- COSYTEC S.A., Abderrahmane Aggoun,[email protected]

- ILOG S.A., Philippe Laborie,[email protected]

- Laboratoire d’ Analyse et d’ Architecture des Sys-temes (LAAS-CNRS), Malik Ghallab,[email protected]

- Laboratoire d’ Informatique Marseille (LIM -CNRS), Camilla Schwind,[email protected]

- MASA Group, Emmanuel Chiva,[email protected]

- ONERA Systems Control and Flight Dynam-

ics Department,TCU On-line Planning andScheduling, Gerard Verfaillie,[email protected]

- THOMSON-CSF, Simon De Givry,[email protected]

- Universite Technologique de Troyes, ChristopheDoniat,[email protected]

Germany- University of Ulm,Coordinating Node, Susanne

Biundo,[email protected]

- Anite Systems GmbH, Marc Niezette,[email protected]

- PLASIM Planungs- und Simulationsbüro, JensKlußmann,[email protected]

- Aachen University of Technology, Gerhard Lake-meyer,[email protected]

- University of Bonn, Armin Cremers,[email protected]

- Bremer Institut fur Betriebstechnik und ange-wandte Arbeitswissenschaft (BIBA), Frithjof We-ber,[email protected]

- Darmstadt University of Technology, UlrichScholz,[email protected]

- German Research Center for Artificial Intelli-gence (DFKI), Mathias Bauer,[email protected]

- University of Freiburg, Bernhard Nebel,[email protected]

- Fraunhofer - Autonomous intelligent Systems(AiS), Joachim Hertzberg,[email protected]



- Technical University of Munich,TCU RobotPlanning, Michael Beetz,[email protected].

de

- Siemens AG, Wendelin Feiten,[email protected]

Greece- University of Macedonia, Dept. of Applied Infor-

matics, Thessaloniki, Ioannis Refanidis,[email protected]

- Aristotle University of Thessaloniki, Ioannis Vla-havas,[email protected]

- Foundation for Research and Technology - Hellas(ICS-FORTH), Dimitrios Plexousakis,[email protected]

- National Centre for Scientific Research”Demokritos”, Constantine Spyropoulos,[email protected]

- Technical University of Athens (ICCS), SpyrosTzafestas,[email protected]

- Technical University of Crete, ManolisKoubarakis,[email protected]

- University of Ioannina, Chrysostomos [email protected]

Hungary- Computer and Automation Research Institute

Hungarian Academy of Sciences (MTA SZTAKI ),Laszlo Monostori,[email protected]

Ireland- University College Cork, National University of

Ireland, Ken Brown,[email protected]

Israel- Ben Gurion University, Ronen Brafman,[email protected]

Italy- DIEE - University of Cagliari, Giuliano Armano,[email protected]

- DEIS - University of Bologna, Paola Mello,[email protected]

- DIST - University of Genoa, Enrico Giunchiglia,[email protected]

- Consiglio Nazionale delle Ricerche - Istituto diPsicologia (IP-CNR), TCU Aerospace Applica-tions, Amedeo Cesta,[email protected]

- University of Perugia,TCU Planning & Schedul-ing for the Web, Alfredo Milani,[email protected]

- Istituto per la Ricerca Scientifica e Tecnologia(IRST), Paolo Traverso,[email protected]

- University of Parma, Agostino Poggi,[email protected]

- University of Brescia, Alfonso Gerevini,[email protected]

The Netherlands- Atos Origin Nederland B.V.,TCU Aerospace Ap-

plications, Tim Grant,[email protected]

- Delft University of Technology, Cees Witteveen,[email protected]


- NLR – National Aerospace Laboratory, Henk Hes-selink,[email protected]

Portugal- Instituto Superior de Engenharia do Porto

ISEP/IPP, Joao Rocha,[email protected]

Slovenia- University of Maribor, Peter Kokol,[email protected]

Spain- iSOCO, Intelligent Software for the Networked

Economy, Antonio Reyes Moro,[email protected]

- Technical University of Catalonia, Llu´ıs Vila,[email protected]

- University of Granada, Luis Castillo,[email protected]

- University Carlos III of Madrid,TCU WorkflowManagement, Daniel Borrajo,[email protected]

- Universitat Politecnica de Catalunya, Institut deRobotica i Informatica Industrial, Tom Creemers,[email protected]

- Universidad Politecnica de Valencia, Eva Onain-dia,[email protected]

- Universitat Rovira i Virgili, Tarragona, MiguelAngel Garcia,[email protected]

Sweden- Linkoping University, Patrick Doherty,[email protected]

- Orebro University, Alessandro Saffiotti,

[email protected]

United Kingdom- BAE Systems Ltd., Andrew Burgess,[email protected]

- British Telecommunications, David Lesaint,[email protected]

- University of Essex, Sam Steel,[email protected]

- University of Edinburgh, John Levine,[email protected]

- University of Huddersfield,TCU Knowledge En-gineering, Lee McCluskey,[email protected]

- University of Manchester, Nikolay Mehandjiev,[email protected]

- The Open University Walton Hall, MassimilianoGaragnani,[email protected]

- Salford University,TCU Intelligent Manufactur-ing, Ruth Aylett,[email protected]

- Troy Associates Ltd., Vince Long,[email protected]

- University of Durham, Julie Porteous,[email protected]

Associated Members- Norman Sadeh,[email protected], Carnegie

Mellon University

- Peter Jarvis,[email protected], SRI

- Brian Drabble, [email protected],On Target Technologies, Inc

- Sylvie Thiebaux, Sylvie.Thiebaux@anu.

edu.au, The Australian National University

�

The network is open to new nodes at any time.


On Managing Temporal Information for Handling Durative Actions in LPG

Documents

Transcript of On Managing Temporal Information for Handling Durative Actions in LPG