Page 69 - Introduction to AI Robotics
P. 69

52
                                     CONNECTS(D1, R1, R2)                         2 The Hierarchical Paradigm
                                     CONNECTS(D1, R2, R1)
                                     STATUS(D1,OPEN)
                                     NEXTTO(IT, D1)

                                       Strips exits and the plan for the robot to physically execute (in reverse
                                     order on the stack) is: GOTODOOR(IT, D1), GOTHRUDOOR(IT, D1).

                              2.2.3  Strips summary

                                     Strips works recursively; if it can’t reach a goal directly, it identifies the prob-
                                     lem (a failed precondition), then makes the failed precondition a subgoal.
                                     Once the subgoal is reached, Strips puts the operator for reaching the sub-
                                     goal on a list, then backs up (pops the stack) and resumes trying to reach the
                                     previous goal. Strips plans rather than execute: it creates a list of operators
                                     to apply; it does not apply the operator as it goes. Strips implementations
                                     requires the designer to set up a:

                                       world model representation
                                       difference table with operators, preconditions, add, and delete lists
                                       difference evaluator

                                     The steps in executing Strips are:

                                     1. Compute the difference between the goal state and the initial state using
                                        the difference evaluation function. If there is no difference, terminate.
                                     2. If there is a difference, reduce the difference by selecting the first operator
                                        from the difference table whose add-list has a predicate which negates the
                                        difference.

                                     3. Next, examine the preconditions to see if a set of bindings for the variables
                                        can be obtained which are all true. If not, take the first false precondition,
                                        make it the new goal and store the original goal by pushing it on a stack.
                                        Recursively reduce that difference by repeating step 2 and 3.
                                     4. When all preconditions for an operator match, push the operator onto
                                        the plan stack and update a copy of the world model. Then return to
                                        the operator with the failed precondition so it can apply its operator or
                                        recurse on another failed precondition.
   64   65   66   67   68   69   70   71   72   73   74