Improved Fast Replanning for Robot Navigation in Unknown Terrain

Transcription

1 Improved Fst Replnning for Robot Nvigtion in Unknown Terrin ollege of omputing Georgi Institute of Technology tlnt, G 0-00 GIT-OGSI-00/ Sven Koenig ollege of omputing Georgi Institute of Technology tlnt, G skoenig@cc.gtech.edu Mxim Likhchev School of omputer Science rnegie Mellon University Pittsburgh, P mxim+@cs.cmu.edu

2 bstrct Mobile robots often operte in domins tht re only incompletely known, for exmple, when they hve to move from given strt coordintes to given gol coordintes in unknown terrin. In this cse, they need to be ble to repln quickly s their knowledge of the terrin chnges. Stentz Focussed ynmic * is heuristic serch method tht repetedly determines shortest pth from the current robot coordintes to the gol coordintes while the robot moves long the pth. It is ble to repln one to two orders of mgnitudes fster thn plnning from scrtch since it modifies previous serch results loclly. onsequently, it hs been extensively used in mobile robotics. In this rticle, we introduce n lterntive to Focussed ynmic * tht implements the sme nvigtion strtegy but is lgorithmiclly different. Focussed ynmic * Lite is simple, esy to understnd, esy to nlyze nd esy to extend, yet is more efficient thn Focussed ynmic *. We believe tht our results will mke *-like replnning methods even more populr nd enble robotics reserchers to dpt them to dditionl pplictions.

3 1 Introduction Mobile robots often operte in domins tht re only incompletely known. In this rticle, we study gol-directed nvigtion problem in unknown terrin where mobile robot hs to move from its current coordintes to given gol coordintes. Robotics reserchers hve investigted vrious nvigtion strtegies to solve it, including the well-known bug lgorithms [LS]. In this pper, we study the following nvigtion strtegy: The robot lwys plns shortest pth from its current coordintes to the gol coordintes under the ssumption tht unknown terrin is trversble. (It cn utilize initil knowledge of the terrin in cse it is vilble.) If it observes obstcles s it follows this pth, it enters them into its mp nd then repets the procedure, until it eventully reches the gol coordintes or ll pths to them re untrversble. This nvigtion strtegy is n exmple of sensor-bsed motion plnning [9, 9]. If we model the nvigtion problem s nvigtion problem on n eight-connected grid with edges tht re either trversble (with cost one) or untrversble, it must terminte becuse the robot either follows the plnned pth to the gol vertex or increses its knowledge bout the true edge costs, which cn hppen only once for ech edge. To implement the nvigtion strtegy, the robot needs to repln shortest pth from its current vertex to the gol vertex whenever it detects tht its current pth is untrversble. The robot could use conventionl grph-serch methods. However, the resulting serch times cn be on the order of minutes for the lrge grphs tht re often used, which dds up to substntil idle times [Ste9]. Focussed ynmic * (*) [Ste9] is probbly the most populr solution to this problem t the moment since it combines the efficiency of heuristic nd incrementl serches, yet still finds shortest pths. It chieves speedup of one to two orders of mgnitudes(!) over repeted * [Pe] serches by modifying previous serch results loclly. * hs been extensively used on rel robots. This includes indoor Nomd robots [KTH01] s well s outdoor HMMWVs nd the UGV emo II vehicles s prt of the RP Unmnned Ground Vehicle progrm [SH9]. It is currently lso being integrted into Mrs Rover prototypes nd tcticl mobile robot prototypes for urbn reconnissnce [HM99, MXH 00, T 00]. * is lso used s prt of other softwre, including the GRMMPS mission plnner for multiple robots [S9]. However, * is very complex nd thus hrd to understnd, nlyze, nd extend. For exmple, while * hs been widely used s blck-box method, it hs not been extended by other reserchers. uilding on our Lifelong Plnning * method [KL01], we therefore present * Lite, novel replnning method tht implements the sme nvigtion strtegy s * but is lgorithmiclly different. Lifelong Plnning * is n incrementl version of * nd thus very similr to *. It is efficient nd hs well-understood properties (for exmple, we cn prove theorems bout its similrity to * nd its efficiency). This lso llows us to extend it esily, for exmple, to use indmissible heuristics nd different tie-breking criteri to gin efficiency. Since * Lite is bsed on LP*, it is simple, esy to understnd, esy to nlyze nd esy to extend. It lso inherits ll of the properties of LP* nd cn be extended in the sme wy s LP*. It hs more thn thirty percent fewer lines of code thn * (without ny coding tricks), uses only 1

4 one tie-breking criterion when compring priorities which simplifies the mintennce of the priorities, nd does not need nested if-sttements with complex conditions tht occupy up to three lines ech which simplifies the nlysis of the progrm flow. Yet, our experiments show tht * Lite is more efficient thn *. The simplicity of * Lite is importnt for optimizing it, integrting it into complete robot rchitectures, nd using it to solve nvigtion tsks other thn gol-directed nvigtion in unknown terrin. We lso provide mthemticlly rigorous nlysis of * Lite, probbly the most rigorous nlysis of ny incrementl heuristic serch method tht hs been pplied to robot nvigtion in unknown terrin. In Section, we motivte the ides behind * Lite. In Section, we then introduce LP* nd describe how it works. In Section, we use LP* to develop two versions of * Lite, the bsic version nd the finl version, nd describe how they cn be optimized. In Section, we illustrte the opertion of the two versions of * Lite with n exmple. In Section finlly, we present experimentl results tht compre * Lite ginst severl other serch methods, both for gol-directed nvigtion in unknown terrin nd for mpping of unknown terrin. The ppendix contins the proofs of the theorems stted in the min text. (s explined in the ppendix, the proofs in the ppendix re for version of LP* tht serches from the gol vertex to the strt vertex.) Motivtion onsider robot-nvigtion tsk in unknown terrin, where the robot lwys observes which of its eight djcent cells re trversble nd then moves with cost one to one of them. The robot strts t the strt cell nd hs to move to the gol cell. It lwys computes shortest pth from its current cell to the gol cell under the ssumption tht cells with unknown trversbility sttus re trversble. It then follows this pth until it reches the gol cell, in which cse it stops successfully, or it observes dditionl untrversble cells, in which cse it recomputes shortest pth from its current cell to the gol cell. Figure 1 illustrtes this nvigtion strtegy. Figure 1 (top) shows the terrin in which the robot hs to move from cell 1 to cell, nd Figure 1 (bottom) shows, before ech movement of the robot, the untrversble cells tht it knows bout together with the pth tht it ttempts to follow. White cells re known to be trversble, blck cells re known to be untrversble, nd gry cells hve unknown trversbility. The robot strts in cell 1. Since ll costs re one, the shortest pth from the current cell 1 to the gol cell seems to be vi cells 1 nd. The robot then moves to cell 1 nd discovers tht cell is untrversble. Now, the shortest pth from the current cell 1 to the gol cell seems to be vi cells 1 nd. The robot then follows this pth to the gol cell. Figure shows the beginning of lrger exmple. It shows the gol distnces (tht is, the length of shortest pth to gol cell) of ll trversble cells nd the shortest pths both before nd fter the robot hs moved long the pth nd discovered the first untrversble cell it did not know bout. ells whose gol distnces hve chnged re shded gry. The gol distnces re

5 Nvigtion Strtegy ctul terrin 1 strt gol Initil Sitution fter the 1st Move fter the nd Move fter the rd Move fter the th Move 1 1 Figure 1: Illustrtion of the Nvigtion Strtegy. importnt becuse one cn esily determine shortest pth from the current cell of the robot to the gol vertex by greedily decresing the gol distnces once the gol distnces hve been computed. Notice tht the gol distnces of only bout 1 percent of the cells hve chnged, nd most of the chnged gol distnces re irrelevnt for reclculting shortest pth from the current cell of the robot to the gol cell. Thus, one cn efficiently reclculte shortest pth from the current cell of the robot to the gol cell by reclculting only those gol distnces tht hve chnged (or hve not been clculted before) nd re relevnt for reclculting the shortest pth. This is wht * Lite does. The chllenge is to identify these cells efficiently. Lifelong Plnning * We first describe Lifelong Plnning * (LP*) [KL01], our incrementl heuristic serch method tht repetedly determines shortest pths between two given vertices s the edge costs of grph chnge. We chose its nme in nlogy to lifelong lerning [Thr9] becuse it reuses informtion from previous serches. We lter use LP* to develop * Lite. LP* is shown in Figure. It is n incrementl serch method tht uses heuristics to focus

6 s strt Knowledge efore the First Move of the Robot s gol Knowledge fter the First Move of the Robot s strt s gol Figure : Simple xmple (Prt 1) the serch. n incrementl serch tends to only reclculte those strt distnces (tht is, distnce from the strt vertex to vertex) tht hve chnged (or hve not been clculted before) [FMSN00] nd heuristic serch tends to only reclculte those strt distnces tht re relevnt for reclculting shortest pth from the strt vertex to the gol vertex [Pe]. LP* thus reclcultes only very few strt distnces. LP* is n incrementl version of * [Pe], probbly the most populr serch method in rtificil intelligence. It pplies to the sme grph serch problems s * nd shres mny similrities with it. For exmple, it uses heuristic knowledge in form of pproximtions of the gol distnces to focus the serch. LP* generlizes * becuse its first serch is the sme s tht of * nd it performs n incrementl * serch fterwrds. LP* lso generlizes version of ynmicswsf-fp [RR9] becuse it reduces to it if the heuristics re uninformed (tht is, zero)..1 Lifelong Plnning *: Nottion Lifelong Plnning * (LP*) pplies to finite grph serch problems on known grphs whose edge costs increse or decrese over time (which cn lso be used to model edges or vertices tht re dded or deleted). Thus, it serches directed grphs, just like *. denotes the finite set of vertices of the grph. denotes the set of successors of vertex in the grph. Similrly, denotes the set of predecessors of vertex in the grph. "!#%$&('*) denotes the cost of moving from vertex to vertex $+,. LP*

7 $ The pseudocode uses the following functions to mnge the priority queue: U.TopKey returns the smllest priority of ll vertices in priority queue. (If is empty, then U.TopKey returns.) U.Pop deletes the vertex with the smllest priority in priority queue nd returns the vertex. U.Insert inserts vertex into priority queue with priority. Finlly, U.Remove removes vertex from priority queue. procedure lcultekey 01 return! " # %$&('!)* + *,!! ; procedure Initilize 0-./ ; 0 for ll 10!.. ; 0! 9,: '!; :" <.= ; 0 U.Insert 9: '!; :( lcultekey 9,: '!; : " ; procedure UpdteVertex *>? 0 if>@.9,: '; :?!!*>?. 9" PredGFIH * %J LK (J ">? ; 0 if>0 1 U.Remove>? ; 0 if *>? 1@.M!>N " U.Insert>O lcultekey>? ; procedure omputeshortestpth 09 while U.TopKey QP R lcultekey $&('!) OR! $%&('!) -@. $%&%') 10S>T. U.Pop ; if+>? UV?!*>? " 1 >?.!! *>? ; 1 for ll W0 Succ *>? UpdteVertex ; 1 else 1 >?. ; 1 for ll W0 Succ *>? #X ># UpdteVertex ; procedure Min 1 Initilize ; 1 forever 19 omputeshortestpth ; 0 Wit for chnges in costs; 1 for ll directed edges> YZ with chnged edge costs Updte the edge cost K *>O"YZ ; UpdteVertexYI ; Figure : (Forwrd Version of) Lifelong Plnning *. ([]\^[ to given gol vertex ^_\^`, knowing both the topology of the grph nd the current edge costs. We use to denote the gol distnce of vertex, tht is, the cost of shortest pth from to ^_\^`. Similrly, we use cb to denote the strt distnce of vertex, tht is, the cost of shortest pth from %[]\[ to. The strt distnces stisfy the following reltionship: lwys determines shortest pth from given strt vertex d boef#gh ikj mon]p J 0Nq1!rst e d b ef gwuwvoef $x f#g!g if fhlf %[]\[ otherwise. (1). Lifelong Plnning *: The Vribles LP* mintins n estimte of the strt distnce 1b of ech vertex. These vlues directly correspond to the g-vlues of n * serch. The initil serch of LP* clcultes the g-vlues of ech vertex in exctly the sme order s *. LP* then crries the g-vlues forwrd

8 i j $ $ x from serch to serch. LP* lso mintins second kind of estimte of the strt distnces. The rhs-vlues re one-step lookhed vlues bsed on the g-vlues nd thus potentilly better informed thn the g-vlues. They lwys stisfy the following reltionship (Invrint 1) ccording to Theorem in the ppendix: fqef#gh mon]p J 0#q1rst e d ef g uwvoef $ x f#g!g if flh f ([]\^[ otherwise. () vertex is clled loclly consistent iff. This concept is similr to stisfying the ellmn eqution for undiscounted deterministic sequentil decision problems [el]. vertex is clled loclly inconsistent iff. If ll vertices re loclly consistent then ll of their g-vlues stisfy d efng h ikj mon]p J 0Nq1!rst e d ef g uwvoef $,x f#g!g if flh f ([]\^[ otherwise. () comprison to qution 1 shows tht ll g-vlues re equl to their respective strt distnces. Thus, the g-vlues of ll vertices equl their strt distnces iff ll vertices re loclly consistent. This concept is importnt becuse one cn then trce bck shortest pth from %[]\[ to ny vertex by lwys moving from the current vertex, strting t, to ny predecessor $ tht $ $!# minimizes until %[]\[ is reched (ties cn be broken rbitrrily). However, LP* does not mke every vertex loclly consistent fter some of the edge costs hve chnged. "!# Insted, it uses heuristics Z_\Z` to focus the serch nd updtes only the g-vlues tht "!#$& re relevnt for computing shortest pth. pproximtes the distnce between vertex nd $. Thus, the heuristics pproximte the gol distnces of the vertices. The heuristics need to be nonnegtive nd (forwrd) consistent [Pe], tht is, obey the tringle inequlity! "!# ' "!#%$ %$!# nd for ll vertices nd $. ^_\^` ^_\^` Z_\Z` LP* mintins priority queue, like *. The priority queue of LP* lwys contins exctly the loclly inconsistent vertices (Invrint ) ccording to Theorem in the ppendix. These re the vertices whose g-vlues LP* potentilly needs to updte to mke them loclly consistent. The keys of the vertices in the priority queue roughly correspond to the f-vlues used by *, nd LP* lwys reclcultes the g-vlue of the vertex ( expnds the vertex ) in the priority queue with the smllest key. This is similr to * tht lwys expnds the vertex in the priority queue with the smllest f-vlue. y expnding vertex, we men executing 10-1 (numbers in brckets refer to line numbers in Figure ). The key of vertex is vector with two components: ^_\^` ef#gh ef#g ef#g ()

9 ' $! "!# ^_\^` where nd 1. This is the vector tht lcultekey() clcultes. The priority of vertex in the priority queue is lwys the sme s its key (Invrint ) ccording to Theorem in the ppendix. Keys re compred ccording to lexicogrphic ordering. For exmple, key is smller thn or equl to key $ $ $ $ ', denoted by, iff either or ( nd ). The first component of the keys corresponds directly to the f-vlues "!# b ^_\^` used by * becuse both the g-vlues nd rhs-vlues of LP* correspond to the g- vlues of * nd the h-vlues of LP* correspond to the h-vlues of *. The second component of the keys corresponds to the g-vlues of *. LP* lwys expnds the vertex in the priority queue with the smllest k -vlue, which corresponds to the f-vlue of n * serch, breking ties in fvor of the vertex with the smllest k -vlue, which corresponds to the g-vlue of n * serch. This is similr to * tht lwys expnds the vertex in the priority queue with the smllest f-vlue, breking ties mong the vertices on the sme brnch of the serch tree in fvor of the vertex with the smllest g-vlue. The resulting behvior of LP* nd * is lso similr. The keys of the vertices expnded by LP* re nondecresing over time ccording to Theorem in the ppendix. This is similr to * since the f-vlues of the vertices expnded by * re lso nondecresing over time (since the heuristics re consistent) nd the g-vlues re lso nondecresing for vertices with the sme f-vlues (since it grows the serch tree).!. Lifelong Plnning *: The Method LP* is shown in Figure. The min function Min() first clls Initilize() to initilize the serch problem 1. Initilize() sets the initil g-vlues of ll vertices to infinity nd sets their rhs-vlues ccording to qution 0-0. Thus, initilly %[]\[ is the only loclly inconsistent vertex nd is inserted into the otherwise empty priority queue with key clculted ccording to qution 0. This initiliztion gurntees tht the first cll to omputeshortestpth() 19 performs exctly n * serch, tht is, expnds exctly the sme vertices s * in exctly the sme order, provided tht * breks ties mong vertices with the sme f-vlues suitbly. Note tht, in n ctul implementtion, Initilize() only needs to initilize vertex when it encounters it during the serch nd thus does not need to initilize ll vertices up front. This is importnt becuse the number of vertices cn be lrge nd only few of them might be reched during the serch. LP* then wits for chnges in edge costs 0. To mintin Invrints 1- if some edge costs hve chnged, it clls UpdteVertex() to updte the rhs-vlues nd keys of the vertices potentilly ffected by the chnged edge costs s well s their membership in the priority queue if they become loclly consistent or inconsistent, nd finlly reclcultes shortest pth 19 by clling omputeshortestpth(), nd itertes. In the following, we give high-level explntion of how omputeshortestpth() works, ppeling to the intuition of the reder. We prove theorems in the ppendix tht mke our explntions more concrete. omputeshortestpth() repetedly expnds loclly inconsistent vertices in the order of their priorities 10. loclly inconsistent vertex is clled loclly overconsis-

10 tent iff. When omputeshortestpth() expnds loclly overconsistent vertex 1-1, then it turns out to hold tht b, which implies tht b. uring the expnsion of vertex, omputeshortestpth() sets the g-vlue of vertex to its rhs-vlue nd thus its strt distnce 1, which is the desired vlue nd lso mkes the vertex loclly consistent. Its g-vlue then no longer chnges until omputeshortestpth() termintes ccording to Theorem 1 in the ppendix. loclly inconsistent vertex is clled loclly underconsistent iff. When omputeshortestpth() expnds loclly underconsistent vertex 1-1, then it simply sets the g-vlue of the vertex to infinity 1. This mkes the vertex either loclly consistent or overconsistent. If the expnded vertex ws loclly overconsistent, then the chnge of its g-vlue cn ffect the locl consistency of its successors 1. Similrly, if the expnded vertex ws loclly underconsistent, then it nd its successors cn be ffected 1. To mintin Invrints 1-, omputeshortestpth() therefore updtes rhs-vlues of these vertices, checks their locl consistency, nd dds them to or removes them from the priority queue ccordingly 0-0. LP* expnds vertices until Z_\Z` is loclly consistent nd the key of the vertex to expnd next is no smller thn the key of ^_\^`. This is similr to * tht expnds vertices until it expnds ^_\^` t which point in time the g-vlue of ^_\^` equls its strt distnce nd the f-vlue of the vertex to expnd next is no smller thn the f-vlue of ^_\Z`. LP* expnds vertex t most twice, nmely t most once when it is loclly underconsistent nd t most once when it is loclly overconsistent, ccording to Theorem 1 in the ppendix. This property implies tht LP* is gurnteed to terminte fter number of vertex expnsions tht is t most twice the number of vertex expnsions of * since * expnds ech vertex t most once. Thus, even though it is known tht there re lwys cses where incrementl serch is not more efficient thn serch from scrtch [NK9], LP* cn never be much worse thn * even in situtions tht re exceptionlly bd for LP*. ) If ^_\^` fter the serch, then there is no finite-cost pth from ([]\^[ to ^_\^`. Otherwise, one cn trce bck shortest pth from ([]\^[ to ^_\^` by lwys moving from the current vertex, strting t ^_\^`, to ny predecessor $ $& $!# tht minimizes until %[]\[ is reched (ties cn be broken rbitrrily) ccording to Theorem 1 in the ppendix. This is similr to wht * cn do if it does not use bckpointers. Thus, LP* does not explicitly mintin serch tree. Insted, it uses the g-vlues to encode it implicitly. more detiled nd forml description of LP* cn be found in [KL01b]. This includes its comprison to * nd proofs of its properties, for exmple tht LP* is efficient becuse it performs incrementl serches nd thus clcultes only those g-vlues tht hve been ffected by cost chnges or hve not been clculted yet in previous serches nd tht LP* is lso efficient becuse it performs heuristic serches nd thus clcultes only the g-vlues of those vertices tht re importnt to determine shortest pth.

11 fter the 1st Move 1 Figure : Known Terrin nd orresponding Grph. * Lite So fr, we hve described our LP*, tht repetedly determines shortest pths between the strt vertex nd the gol vertex s the edge costs of grph chnge. We now use LP* to develop * Lite [KL0], tht repetedly determines shortest pths between the current vertex of the robot nd the gol vertex s the edge costs of grph chnge while the robot moves towrds the gol vertex. * Lite does not mke ny ssumptions bout how the edge costs chnge, whether they go up or down, whether they chnge close to the current vertex of the robot or fr wy from it, or whether they chnge in the world or only becuse the robot revised its initil estimtes. The gol-directed nvigtion problem in unknown terrin then is specil cse of this problem, where the grph is n eight-connected grid whose edge costs re initilly one nd chnge to infinity when the robot discovers tht they cnnot be trversed. Figure, for exmple, shows the untrversble cells tht the robot knows bout fter its first movement for the exmple from Figure 1 together with the corresponding grph. Solid edges hve cost one nd dshed edges hve infinite cost. We now first describe simple version of * Lite nd then more sophisticted version. ecuse both versions of * Lite re bsed on LP*, they shre mny properties with * nd re efficient..1 The sic Version of * Lite We hve lredy rgued tht mny gol distnces remin unchnged s the robot moves to the gol vertex nd observes obstcles in the process. Thus, we cn use version of LP* for the gol-directed nvigtion problem in unknown terrin. We first need to switch the serch direction of LP*. The version presented in Figure serches from the strt vertex to the gol vertex nd thus its g-vlues re estimtes of the strt distnces. The version presented in Figure serches from the gol vertex to the strt vertex nd thus its g-vlues re estimtes of the gol distnces. It ws derived from the originl grph by reversing ll edges of the grph nd "!#$ exchnging the strt nd gol vertex. The heuristics now need to be nonnegtive nd!#!#'!#%$& $!# bckwrd consistent, tht is, obey nd %[]\[ %[]\[ 9 %[]\[ %[]\[

12 The pseudocode uses the following functions to mnge the priority queue: U.TopKey returns the smllest priority of ll vertices in priority queue. (If is empty, then U.TopKey returns.) U.Pop deletes the vertex with the smllest priority in priority queue nd returns the vertex. U.Insert inserts vertex into priority queue with priority. Finlly, U.Remove removes vertex from priority queue. procedure lcultekey 01 return! " # 9,: '!; :, " *,!! ; procedure Initilize 0-./ ; 0 for ll 10!.. ; 0! %$&('!) <.= ; 0 U.Insert $%&('!) lcultekey $%&('!) " ; procedure UpdteVertex *>? 0 if>@.%$%&%')?!!*>? <. 9, SuccGFZH K>O%J* (J " ; 0 if>0 1 U.Remove>? ; 0 if *>? 1@.M!>N " U.Insert>O lcultekey>? ; procedure omputeshortestpth 09 while U.TopKey QP R lcultekey 9,: '!; : OR! 9: '!; : c@. 9,: '; : " 10S>T. U.Pop ; if+>? UV?!*>? " 1 >?.!! *>? ; 1 for ll W0 Pred>N UpdteVertex ; 1 else 1 >?. ; 1 for ll W0 Pred>N?X >N UpdteVertex ; procedure Min 1 Initilize ; 1 forever 19 omputeshortestpth ; 0 Wit for chnges in costs; 1 for ll directed edges> YZ with chnged edge costs Updte the edge cost K *>O"YZ ; UpdteVertex>N ; Figure : ckwrd Version of Lifelong Plnning *. for ll vertices nd $ Pred. More generlly, since the robot moves nd thus chnges %[]\[, the heuristics needs to stisfy this property for ll ) ([]\^[. If ([]\^[ fter the serch, then there is no finite-cost pth from ([]\^[ to ^_\^`. Otherwise, one cn follow shortest pth from %[]\[ to ^_\^` by lwys moving from the current vertex, strting t %[]\[, to ny successor $ tht minimizes! $ $ until ^_\^` is reched (ties cn be broken rbitrrily). To solve the gol-directed nvigtion problem in unknown terrin, the lcultekey, Initilize, UpdteVertex, nd omputeshortestpth functions cn remin unchnged. However, the Min function needs to get extended so tht it moves the robot nd then reclcultes the priorities of the vertices in the priority queue ppropritely. This is necessry becuse the heuristics chnge when the robot moves, since they re computed with respect to the current vertex of the robot. This only chnges the priorities of the vertices in the priority queue but not which vertices re consistent nd thus in the priority queue. Figure shows the resulting method, clled the bsic version of * Lite. The min function Min() first clls Initilize() to initilize the serch problem 1. Initilize() sets the initil g-vlues of ll vertices to infinity nd sets their rhs-vlues ccording to the equivlent of qution 0-0. Thus, initilly Z_\Z` is the only loclly inconsistent vertex 10

13 The pseudocode uses the following functions to mnge the priority queue: U.TopKey returns the smllest priority of ll vertices in priority queue. (If is empty, then U.TopKey returns.) U.Pop deletes the vertex with the smllest priority in priority queue nd returns the vertex. U.Insert!,t inserts vertex into priority queue with priority. U.Updte chnges the priority of vertex in priority queue to. (It does nothing if the current priority of vertex lredy equls.) Finlly, U.Remove removes vertex from priority queue. procedure lcultekey 01 return ++,! " # 9,: '!; :,, "?! " ; procedure Initilize 0 c./ ; 0 for ll 10!. Q. ; 0!! $%&('!) Q.= ; 0 U.Insert $%&%') lcultekey $&('!) ; procedure UpdteVertex *>? 0 if *>@. $&('!)?!>? Q. 9 SuccGFIH K>,%J* %J ; 0 if *>0 1 U.Remove *>? ; 0 if *>? 1@.!!*>? " U.Insert> lcultekey *>? " ; 09 while U.TopKey <P R lcultekey 9,: '!; : OR! 9,: '; : -@. 9,: '!; : 10 >. U.Pop ; if *>N UV!>? 1 *>? Q.!>? ; 1 for ll W0 Pred *>? UpdteVertex ; procedure omputeshortestpth 1 else 1 *>? Q. ; 1 for ll W0 Pred *>? #X procedure Min() 1 Initilize ; 1 omputeshortestpth ; >N UpdteVertex ; 19 while 9,: '!; :.@ $&('!) 0 /* if+ 9,: '!; : <. V then there is no known pth */ 1 9,: '!; :Q. 9, K Succ 9 H %9,: '!; : J + J ; Move to 9,: '!; : ; Scn grph for chnged edge costs; if ny edge costs chnged for ll directed edges>oyz with chnged edge costs K the edge cost >"YZ ; UpdteVertex>? ; for ll W0 9 U.Updte! lcultekey " ; 0 omputeshortestpth ; Figure : * Lite: sic Version. nd is inserted into the otherwise empty priority queue with key clculted ccording to the equivlent of qution 0. Note tht, in n ctul implementtion, Initilize() only needs to initilize vertex when it encounters it during the serch nd thus does not need to initilize ll vertices up front. This is importnt becuse the number of vertices cn be lrge nd only few of them might be reched during the serch. The bsic version of * Lite then computes shortest pth from the current vertex of the robot %[]\[ to the gol vertex 1. If the robot hs not reched the gol vertex yet 19, it mkes one trnsition long the shortest pth nd updtes %[]\[ to reflect the current vertex of the robot 1 -. (In the pseudocode, we hve included comment on how the robot cn detect tht there is no pth but do not prescribe wht it should do in this cse. For the gol-directed nvigtion problem in unknown terrin, for exmple, it should stop nd nnounce tht there is no pth since obstcles do not dispper.) It then scns

14 b for chnges in edge costs. To mintin Invrints 1- if some edge costs hve chnged, it clls UpdteVertex() to updte the rhs-vlues nd keys of the vertices potentilly ffected by the chnged edge costs s well s their membership in the priority queue if they become loclly consistent or inconsistent. Finlly, it updtes the priorities of ll vertices in the priority queue -9, reclcultes shortest pth 0, nd itertes. In the ppendix, we prove the correctness of the bsic version of * Lite: Theorem 1 (= Theorem 1 in the ppendix) omputeshortestpth of the bsic version of * Lite expnds vertex t most twice, nmely t most once when it is loclly underconsistent nd t most once when it is loclly overconsistent, nd thus termintes. One cn then follow shortest pth from %[]\[ to ^_\^` by lwys moving from the current vertex, strting t %[]\[, to ny successor $ tht minimizes "!# $ %$ until Z_\Z` is reched (ties cn be broken rbitrrily).. The Finl Version of * Lite The bsic version of * Lite hs the disdvntge tht the repeted reordering of the priority queue -9 cn be expensive since the priority queue often contins lrge number of vertices. The finl version of * Lite, shown in Figure, uses method derived from * [Ste9] to void hving to reorder the priority queue. ifferences to the bsic version of * Lite "!# $ re shown in bold. The heuristics now need to be nonnegtive nd forwrd-bckwrd "!#$ $& ' "!#%$ %$! $ $ consistent, tht is, obey for ll vertices "!# $!#%$ $. They lso "!#$ ' "!#%$& need to be dmissible no mtter wht the gol vertex is, tht is, obey for ll vertices "!#%$, where "!#%$ %$ b denotes the cost of shortest pth from vertex to vertex. Theorem in the ppendix proves tht heuristics with these properties lso hve the property tht heuristics for the bsic version of * Lite need to stisfy. Yet, these properties re not overly restrictive since Theorem in the ppendix proves tht they re gurnteed to hold if the heuristics were derived by relxing the serch problem, which will lmost lwys be the cse nd holds for ll heuristics used in this rticle. The finl version of * Lite uses priorities tht re lower bounds on the priorities tht the bsic version of * Lite uses for the corresponding vertices. They re initilized in the sme wy s the bsic version of * Lite initilizes them. fter the robot hs moved from vertex to some vertex $ where it detects chnges in edge costs, the first element of the priorities cn hve "!# $ decresed by t most. (The second component does not depend on the heuristics nd thus remins unchnged.) Thus, in order to mintin lower bounds, * Lite needs to subtrct "!#%$& from the first element of the priorities of ll vertices in the priority queue. However,! $ since is the sme for ll vertices in the priority queue, the order of the vertices in the priority queue does not chnge if the subtrction is not performed. Then, when new priorities "!#$& re computed, their first components re by too smll reltive to the priorities in the 1

15 The pseudocode uses the following functions to mnge the priority queue: U.TopKey returns the smllest priority of ll vertices in priority queue. (If is empty, then U.TopKey returns.) U.Pop deletes the vertex with the smllest priority in priority queue nd returns the vertex. U.Insert inserts vertex into priority queue with priority. Finlly, U.Remove removes vertex from priority queue. procedure lcultekey 01 return + *,,! " # +9,: '!; : + *,,!! ; procedure Initilize 0 -./ ; 0.# 0 for ll 0!! <. <. ; 0! $%&%') <.= ; 0 U.Insert $%&('!) lcultekey $%&('!) " ; procedure UpdteVertex *>? 0 if>@. $%&%')?!!*>?. 9 K SuccGFZH *>O,%J* (J " ; 0 if>0 1 U.Remove>? ; 09 if *>? c@.!>? U.Insert *>O lcultekey>? ; 10 while U.TopKey RP lcultekey 9,: '!; : OR!! 9,: '!; : 1@. 9,: '!; : ". U.TopKey 1 >. U.Pop ; procedure omputeshortestpth 1 R if lcultekeyo 1 U.InsertQ lcultekeyo " 1 else if *>? U!>? 1 >? Q.!! *>? ; 1 for ll 10 Pred>? UpdteVertex ; 1 else 19 >? Q. ; 0 for ll 10 Pred>? #X procedure Min 1. Initilize ; omputeshortestpth ; >N UpdteVertex ; while +9,: '!; :c@. $%&('!) /* if * 9,: '!; : Q.V then there is no known pth */ +9,: '!; :<. < 9" Succ 9 K H 9,: '; : J J " ; Move to +9,: '!; : ; Scn grph for chnged edge costs; 9 if ny edge costs chnged 0., 1. for ll directed edges>oyz with chnged edge costs Updte the edge cost K *>O YI ; UpdteVertex>N ; omputeshortestpth ; "!#$& Figure : * Lite: Finl Version. priority queue. Thus, hs to be dded to their first components every time some edge costs chnge. If the robot moves gin nd then detects cost chnges gin, then the constnts need to get dded up. We do this in the vrible! 0. Thus, whenever new priorities re computed, the vrible "! hs to be dded to their first components, s done in 01. Then, the order of the vertices in the priority queue does not chnge fter the robot moves nd the priority queue does not need to get reordered. The priorities, on the other hnd, re lwys lower bounds on the corresponding priorities of the bsic version of * Lite fter the first component of the priorities of the bsic version of * Lite hs been incresed by the current vlue of!, tht 1

16 is, lower bounds on the vlues clculted by lcultekey() 01. We exploit this property by chnging omputeshortestpth s follows. fter omputeshortestpth hs removed vertex with the smllest priority _`s U.TopKey from the priority queue 1, it now uses lcultekey to compute the priority tht it should hve hd. If _` s lcultekey then it reinserts the removed vertex with the priority clculted by lcultekey into the priority queue 1-1. Thus, it remins true tht the priorities of ll vertices in the priority queue re lower bounds on the corresponding priorities of the bsic version of * Lite fter the first components of the priorities of the bsic version of * Lite hve been incresed by the current vlue of "!. If _` s lcultekey, then it holds tht _` s lcultekey since _` s ws lower bound on the vlue returned by lcultekey(). In this cse, omputeshortestpth performs the sme opertions for vertex s omputeshortestpth of the bsic version of * Lite 1-0. omputeshortestpth performs these opertions for vertices in the exct sme order s omputeshortestpth of the bsic version of * Lite, which implies tht the finl version of * Lite shres mny properties with the bsic version of * Lite, including its correctness: Theorem (= Theorem 1 in the ppendix) omputeshortestpth of the finl version of * Lite expnds vertex t most twice, nmely t most once when it is loclly underconsistent nd t most once when it is loclly overconsistent, nd thus termintes. One cn then follow shortest pth from ([]\^[ to ^_\^` by lwys moving from the current vertex, strting t %[]\[, to ny successor $ "!# $ $ tht minimizes until ^_\^` is reched (ties cn be broken rbitrrily). n xmple We illustrte * Lite using the two eight-connected grids from Figure. To mke the serch methods comprble, their serch lwys strts t ^_\^` nd proceeds towrds the current cell of the robot. Furthermore, we consider the current cell of the robot to be expnded by ll serch methods. We use the mximum of the bsolute differences of the x nd y coordintes of two cells s n pproximtion of their distnce. ells expnded by the methods re shded gry in Figure. s the figure shows, the heuristic serch outperforms the uninformed serches, nd the incrementl serch outperforms the complete (tht is, nonincrementl) ones fter the first move of the robot (where previous serch results re vilble). The figures lso illustrte tht the combintion of heuristic nd incrementl serch performed by both versions of * Lite decreses the number of expnded cells even more thn either heuristic serch or n incrementl serch individully. In prticulr, the initil serch of both versions of * Lite expnds exctly the sme cells s n * serch if * breks ties between vertices with the sme f-vlues suitbly. In our exmple, we broke ties in the most dvntgeous wy for * nd thus both versions of * Lite nd * expnd not exctly the sme cells. The second serch of both 1

17 efore the First Move of the Robot uninformed serch heuristic serch bredth-first serch * incrementl serch complete serch s gol s strt ynmicswsf-fp (with erly termintion) s gol s strt * Lite s gol s gol s strt s strt fter the First Move of the Robot uninformed serch heuristic serch bredth-first serch * incrementl serch complete serch s gol s strt ynmicswsf-fp (with erly termintion) s gol s strt s strt s strt * Lite s gol s gol Figure : Simple xmple (Prt ). versions of * Lite expnds only subset of those cells whose gol distnces chnged (or hd not been clculted before). Thus, both versions of * Lite result in substntil svings over n * serch tht replictes most of its previous serch. We now step through the exmple from Figure 1 to show the opertion of both versions of * Lite. Figure 9 (top) shows the untrversble cells tht the robot knows bout initilly. It lso shows the heuristics of the trversble cells, tht is, the pproximtion of the distnce from the strt cell to the trversble cell given by the mximum of the bsolute differences of the x nd y coordintes of both cells. Figure 9 (bottom) shows the g-vlues nd rhs-vlues of the trversble cells nd, for loclly inconsistent cells, lso their priorities. t every point in time exctly the loclly inconsistent cells re in the priority queue ccording to Invrint. The loclly inconsistent cell with the smllest key hs bold border to indicte tht it will be expnded next. The 1

18 sic nd Finl Version of * Lite First ll to omputeshortestpth heuristics 1 h= 1 h= 1 h= strt/robot h= 0 h= h= 1 h= h= h= h= h= h= h= gol Initiliztion Step 1 Step rhs= 0 k= [;0] rhs= 1 rhs= 1 k= [;1]k= [;1] g= 0 rhs= 1 rhs= 0 k= [;1] rhs= k= [;] rhs= k= [;] g= 1 rhs= rhs= 1 rhs= 1 k= [;] k= [;1] g= 0 rhs= rhs= 1 rhs= 0 k= [;] k= [;1] Step Step Step rhs= k= [;] rhs= k= [;] g= 1 g= 1 rhs= rhs= 1 rhs= 1 k= [;] g= 0 rhs= rhs= 1 rhs= 0 k= [;] k= [;1] rhs= k= [;] g= rhs= rhs= k= [;] g= 1 g= 1 rhs= rhs= 1 rhs= 1 k= [;] g= 0 rhs= rhs= 1 rhs= 0 k= [;] k= [;1] rhs= k= [;] g= rhs= rhs= k= [;] g= rhs= rhs= k= [;] g= 1 g= 1 rhs= rhs= 1 rhs= 1 k= [;] g= 0 rhs= rhs= 1 rhs= 0 k= [;] k= [;1] Figure 9: Illustrtion of the Opertion of the sic nd Finl Versions of * Lite. grid lbelled Initiliztion shows the vlues directly before omputeshortestpth() is clled for the first time. The next grids show the vlues fter ech itertion of the first cll to omputeshortestpth(). If the g-vlue of n expnded cell is lrger thn its rhs-vlue, omputeshortestpth() sets the g-vlue of the cell to its rhs-vlue. Otherwise, omputeshortestpth() sets the g-vlue to infinity. To mintin Invrints 1-, omputeshortestpth() then reclcultes the rhs-vlues of the cells potentilly ffected by this ssignment, checks whether the cells become loclly consistent or inconsistent, nd (if necessry) removes them from or dds them to the priority queue. It then repets this process until it is sure tht it hs found shortest pth, which requires it to reclculte some gol distnces but not ll of them. The lst grid shows the vlues fter omputeshortestpth() returns. Note tht n * serch cn expnd exctly the sme cells in exctly the sme order. One cn then follow shortest pth from the current cell of the robot to the gol cell by strting t the current cell nd lwys greedily decresing the gol distnce. ny wy of doing this results in shortest pth from the current cell to the gol cell. Since ll costs re one, this mens tht the shortest pth from the current cell 1 to gol cell is vi cells 1 nd. The robot then moves to cell 1 nd discovers tht cell is untrversble. Figure 10 shows how the bsic version of * Lite continues nd Figure shows how the finl version of * Lite continues. Figure 10 (top) shows the grid s it is now perceived by the robot. 1

19 sic Version of * Lite Second ll to omputeshortestpth() heuristics 1 h= h= h= strt h= 1 h= robot h= 0 h= h= 1 h= 1 h= h= h= h= gol dge ost hnges Step 1 Step rhs= rhs= k= [;]k= [;] g= rhs= g= rhs= k= [;] rhs= k= [;] g= 1 rhs= rhs= 1 k= [;] k= g= 0 rhs= 1 rhs= 0 k= [;1] rhs= rhs= k= [;]k= [;] g= k=[;] rhs= k= [;] rhs= k= [;] g= 1 rhs= 1 k= g= 0 rhs= 1 rhs= 0 k= [;1] rhs= rhs= k= [;]k= [;] g= k= [;] rhs= k= [;] rhs= k= [;] k= g= 1 rhs= rhs= 1 k= [;] rhs= k= [;] g= 1 rhs= 1 g= 0 rhs= 0 Step Step 1 1 rhs= rhs= k= [;]k= [;] g= k= [;] rhs= k= [;] g= rhs= rhs= k= [;] g= 1 rhs= 1 k= g= 1 g= 0 rhs= rhs= 1 rhs= 0 k= [;] rhs= rhs= k= [;]k= [;] g= rhs= k= [;] g= rhs= rhs= k= [;] g= g= 1 rhs= rhs= 1 k= g= 1 g= 0 rhs= rhs= 1 rhs= 0 k= [;] Figure 10: Illustrtion of the Opertion of the sic Version of * Lite, ontinuing Figure 9. The figure lso shows the new heuristics of the trversble cells. To mintin Invrints 1-, the bsic version of * Lite first updtes the rhs-vlues nd keys of the cells djcent to s well s their membership in the priority queue if they become loclly consistent or inconsistent. It lso updtes the priorities of ll cells in the priority queue to reflect the new heuristics. The grid lbelled dge ost hnges shows the vlues directly before omputeshortestpth() is clled for the second time. The next grids show the vlues fter ech itertion of the second cll to omputeshortestpth(). Finlly, the lst grid shows the vlues fter omputeshortestpth() returns. The shortest pth from the current cell 1 to gol cell is vi cells 1 nd. The robot then follows this pth from its current cell to the gol cell without observing dditionl untrversble cells nd thus without further clls to omputeshortestpth()..1 Optimiztions We implemented both the bsic nd finl version of * Lite, using stndrd binry heps s priority queues. There re severl wys of optimizing both versions of * Lite without chnging their overll opertion, which we discuss in the following in the context of the finl version of 1

20 Finl Version of * Lite Second ll to omputeshortestpth() heuristics 1 h= h= h= strt h= 1 h= robot h= 0 h= key modifier (k m ) = 1 h= 1 h= 1 h= h= h= h= gol dge ost hnges Step 1 Step rhs= rhs= k= [;]k= [;] g= rhs= g= rhs= k= [;] rhs= k= [;] g= 1 rhs= rhs= 1 k= [;] k= g= 0 rhs= 1 rhs= 0 k= [;1] rhs= rhs= k= [;]k= [;] g= k= [;] rhs= k= [;] rhs= k= [;] g= 1 rhs= 1 k= g= 0 rhs= 1 rhs= 0 k= [;1] rhs= rhs= k= [;]k= [;] g= k= [;] rhs= k= [;] rhs= k= [;] k= g= 1 rhs= rhs= 1 k= [;] rhs= k= [;] g= 1 rhs= 1 g= 0 rhs= 0 Step Step 1 1 rhs= rhs= k= [;]k= [;] g= k= [;] rhs= k= [;] g= rhs= rhs= k= [;] g= 1 rhs= 1 k= g= 1 g= 0 rhs= rhs= 1 rhs= 0 k= [;] rhs= rhs= k= [;]k= [;] g= rhs= k= [;] g= rhs= rhs= k= [;] g= g= 1 rhs= rhs= 1 k= g= 1 g= 0 rhs= rhs= 1 rhs= 0 k= [;] Figure : Illustrtion of the Opertion of the Finl Version of * Lite, ontinuing Figure 9. * Lite, the optimized version of which is shown in Figure 1. First, the termintion condition of omputeshortestpth() cn be chnged to mke omputeshortestpth() more efficient. s stted, omputeshortestpth() termintes when the strt vertex is loclly consistent nd its key is less thn or equl to U.TopKey() 10. However, omputeshortestpth() cn lso terminte when the strt vertex is loclly overconsistent nd its key is less thn or equl to U.TopKey(). To understnd why this is so, ssume tht the strt vertex is indeed loclly overconsistent nd its key is less thn or equl to U.TopKey(). Then, its key must be equl to U.TopKey() since U.TopKey() is the smllest key of ny loclly inconsistent vertex. Thus, omputeshortestpth() could expnd the strt vertex next, in which cse it would set its g-vlue to its rhs-vlue. The strt vertex then becomes loclly consistent ccording to Theorem 1 in the ppendix, its key is less thn or equl to U.TopKey(), nd omputeshortestpth() thus termintes. t this point in time, the g-vlue of the strt vertex equls its gol distnce. Thus, omputeshortestpth() cn lredy terminte when the strt vertex is not loclly underconsistent nd its key is less thn or equl to U.TopKey() 10. In this cse, the strt vertex cn remin loclly inconsistent fter omputeshortestpth() termintes nd its g-vlue thus my not be equl to its gol distnce (its rhs-vlue continues to be equl to its gol distnce). This is not problem since the g-vlue is not used to determine how the robot should 1

21 The pseudocode uses the following functions to mnge the priority queue: U.Top returns vertex with the smllest priority of ll vertices in priority queue. U.TopKey returns the smllest priority of ll vertices in priority queue. (If is empty, then U.TopKey returns.) U.Insert inserts vertex into priority queue with priority. U.Updte!t chnges the priority of vertex in priority queue to. (It does nothing if the current priority of vertex lredy equls.) Finlly, U.Remove removes vertex from priority queue. procedure lcultekey 01 return?+,! " # +9: '!; :( "?+,! " ; procedure Initilize 0 c./ ; 0.=I 0 for ll 10! <. Q. ; 0?! $&('!) Q.= ; 0 U.Insert $%&%')"O 9: '!; :,,($&('!)* = ; procedure UpdteVertex *>? 0 if (+>? 1@.?!*>? N > 0 1 U.Updte>O \Z` K >?` \[]r r +>N " ; 0 else if *>? 1@.M!>N N > 0 1 U.Insert *>O \Z` K >`\[]r r>? ; 09 else if *>?.M!>N N >0 1 U.Remove>? ; 10 while U.TopKey WP R lcultekey 9,: '!; : OR! 9,: '; : U 9,: '!; : >. U.Top ; 1 #&). U.TopKey ; 1 V. lcultekey>n " ; 1 if * &%) R P 1 U.Updte>O, 1 else if+>? U?!*>? " 1 *>? <.!>? ; 1 U.Remove *>? ; 19 for ll 0 Pred *>? 0 *?! K!">N *>? " ; procedure omputeshortestpth 1 UpdteVertex ; else &%).*>? ; *>? <. ; for ll 0 Pred *>??X >N if! <. K ">? &%) $&('!)?!. 9," Succ 9 K H %J* %J* ; UpdteVertex ; procedure Min 9 - ) ' 9,:. 9,: '; : 0 Initilize ; 1 omputeshortestpth ; while +9: '!; :1@. $%&%') /* if! 9,: '!; : <. M then there is no known pth */ +9: '!; :<. < 9,] Succ 9 K H %9,: '!; :, J + J " ; Move to +9,: '!; : ; Scn grph for chnged edge costs; if ny edge costs chnged. O ) ' 9,:,9: '!; :" 9 +) ' 9:.%9,: '!; : 0 for ll directed edges *>O YZ with chnged edge costs 1 K &%). K>O YZ ; K Updte the edge cost >"YZ ; K if ( &) U K>OYZ ) if>@. $%&%')?!!*>? <.?!>? K *>O YZ *YZ " ; else *!!*>? <. K &%) +YZ if>@. $%&%')?!!*>? <. 9, SuccGFZH K>O(J (J " ; UpdteVertex *>? ; omputeshortestpth ; Figure 1: * Lite: Finl Version (optimized version). 19

22 move. The only difference is tht now the rhs-vlue of the strt vertex (insted of its g-vlue) being infinity indictes tht there is no pth from the strt vertex to the gol vertex. Second, vertex sometimes gets removed from the priority queue on line 0 nd then immeditely reinserted on line 09. In this cse, it is often more efficient to leve the vertex in the priority queue nd only updte its priority ( 0 ). Third, when UpdteVertex on line 1 computes the rhs-vlue for predecessor of n overconsistent vertex (tht is, vertex whose g-vlue is lrger thn its rhs-vlue) it is unnecessry to tke the minimum over ll of its respective successors since only the g-vlue of the overconsistent vertex hs chnged. Since it decresed, it cnnot increse the rhs-vlues of the predecessors. Thus, it is sufficient to compute the rhs-vlue s the minimum of its old rhs-vlue nd the sum of the cost of moving from the predecessor to the overconsistent vertex nd the new g-vlue of the overconsistent vertex ( 0 ). similr optimiztion cn be mde for the computtion of the rhs-vlue of vertex fter the cost of one of its outgoing edges hs chnged ( ). Fourth, when UpdteVertex on line 0 computes the rhs-vlue for predecessor of n underconsistent vertex (tht is, vertex whose g-vlue is smller thn its rhs-vlue), the only g-vlue tht hs chnged is the g-vlue of the underconsistent vertex. Since it incresed, the rhs-vlue of the predecessor cn only get ffected if its old rhs-vlue ws bsed on the old g- vlue of the underconsistent vertex. This cn be used to decide whether the predecessor needs to get updted nd its rhs-vlue needs to get recomputed ( - ). similr optimiztion cn be mde for the computtion of the rhs-vlue of vertex fter the cost of one of its outgoing edges hs chnged ( - ). Fifth, there re severl smll optimiztions one cn perform. For exmple, the priority on line 0 cn be clculted directly ( 0 ), lcultekey on lines 1-1 needs to clculte the priority of vertex only once ( 1 ), nd the vertex with the highest priority needs to get removed on line 1 only if line 1 does not reinsert it gin immeditely fterwrds ( 1, 1, 1 ). xperimentl Results We now compre (focussed) * nd vrious versions of the optimized finl version of * Lite. We implemented ll methods using stndrd binry heps s priority queues (lthough using more complex dt structures, such s Fiboncci heps, s priority queues could possibly mke U.Updte() more efficient). Since they move the robot in the sme wy nd * hs lredy been demonstrted with gret success on rel robots, we only need to perform simultion study. We need to compre the totl plnning time of the methods. Since the ctul plnning times re implementtion nd mchine dependent, they mke it difficult for others to reproduce the results of our performnce comprison. We therefore use three mesures tht ll correspond to common opertions performed by the methods nd thus hevily influence their plnning 0

23 0 percent of extr vertex expnsions 0 Overhed of Focussed * Reltive to the Finl Optimized Version of * Lite (in percent) x10 0x0 0x0 0x0 mze size percent of extr vertex ccesses 10 percent of extr hep percoltes x10 0x0 0x0 0x0 mze size 0 10x10 0x0 0x0 0x0 mze size Figure 1: Gol-irected Nvigtion in Unknown Terrin (1). times, yet re implementtion nd mchine independent: the totl number of vertex expnsions, the totl number of hep percoltes (exchnges of prent nd child in the hep), nd the totl number of vertex ccesses (for exmple, to red or chnge their vlues). We run the experiments on the MissionLb robot simultion system [M9]. The terrin resembles office environments. The robot lwys observes which of its eight djcent cells is trversble nd cn then move to one of them. We use gin the mximum of the bsolute differences of the x nd y coordintes of ny two cells s pproximtions of their distnce. ll figures grph the three performnce mesures of the other methods s percent difference reltive to * Lite. Thus, * Lite lwys scores zero. The figures lso show the corresponding 9 percent confidence intervls to demonstrte tht our conclusions re sttisticlly significnt..1 Gol-irected Nvigtion in Unknown Terrin We first perform experiments for gol-directed nvigtion in unknown terrin. 1