Additive Pattern Database Heuristics

We explore a method for computing admissible heuristic evaluation functions for search problems. It utilizes pattern databases, which are precomputed tables of the exact cost of solving various subproblems of an existing problem. Unlike standard pattern database heuristics, however, we partition our problems into disjoint subproblems, so that the costs of solving the different subproblems can be added together without overestimating the cost of solving the original problem. Previously, we showed how to statically partition the sliding-tile puzzles into disjoint groups of tiles to compute an admissible heuristic, using the same partition for each state and problem instance. Here we extend the method and show that it applies to other domains as well. We also present another method for additive heuristics which we call dynamically partitioned pattern databases. Here we partition the problem into disjoint subproblems for each state of the search dynamically. We discuss the pros and cons of each of these methods and apply both methods to three different problem domains: the sliding-tile puzzles, the 4-peg Towers of Hanoi problem, and finding an optimal vertex cover of a graph. We find that in some problem domains, static partitioning is most effective, while in others dynamic partitioning is a better choice. In each of these problem domains, either statically partitioned or dynamically partitioned pattern database heuristics are the best known heuristics for the problem

Towers of Hanoi and generalized Towers of Hanoi

We investigate the time and space used by algorithms which solve the Towers of Hanoi problem

An Integrated Planning Representation Using Macros, Abstractions, and Cases

Planning will be an essential part of future autonomous robots and integrated intelligent systems. This paper focuses on learning problem solving knowledge in planning systems. The system is based on a common representation for macros, abstractions, and cases. Therefore, it is able to exploit both classical and case based techniques. The general operators in a successful plan derivation would be assessed for their potential usefulness, and some stored. The feasibility of this approach was studied through the implementation of a learning system for abstraction. New macros are motivated by trying to improve the operatorset. One heuristic used to improve the operator set is generating operators with more general preconditions than existing ones. This heuristic leads naturally to abstraction hierarchies. This investigation showed promising results on the towers of Hanoi problem. The paper concludes by describing methods for learning other problem solving knowledge. This knowledge can be represented by allowing operators at different levels of abstraction in a refinement

Becoming Reactive by Concretization

One way to build a reactive system is to construct an action table indexed by the current situation or stimulus. The action table describes what course of action to pursue for each situation or stimulus. This paper describes an incremental approach to constructing the action table through achieving goals with a hierarchical search system. These hierarchies are generated with transformations called concretizations, which add constraints to a problem and which can reduce the search space. The basic idea is that an action for a state is looked up in the action table and executed whenever the action table has an entry for that state; otherwise, a path is found to the nearest (cost-wise in a graph with costweighted arcs) state that has a mappring from a state in the next highest hierarchy. For each state along the solution path, the successor state in the path is cached in the action table entry for that state. Without caching, the hierarchical search system can logarithmically reduce search. When the table is complete the system no longer searches: it simply reacts by proceeding to the state listed in the table for each state. Since the cached information is specific only to the nearest state in the next highest hierarchy and not the goal, inter-goal transfer of reactivity is possible. To illustrate our approach, we show how an implemented hierarchical search system can completely reactive

An investigation of a manipulative simulation in the learning of recursive programming

Recursion is a fundamentally important topic in Computer Sciences; Even so, it is often omitted in introductory courses, or discussed only briefly. This is likely due, at least in part, to the fact that teaching recursion has been difficult. Perhaps the biggest problem in teaching recursion is that there are few, if any, naturally existing examples of recursion in our lives. However, successful simulations have shown that the computer may hold the key to solving this problem. A simulation of recursion presented to students before formal classroom instruction can provide a foundation of concrete experiences to build upon. The challenge is to develop an appropriate simulation and lesson plan for introducing recursion to students early in their programming experience;This research reviews previous attempts at teaching recursion, including detailed lesson plans, mental models of recursion, and other simulations. Then, a new simulation and lesson plan for its use are described. The effectiveness of the simulation is studied using two groups of students enrolled in a college-level, introductory programming course. Results indicate that students who used the simulation as their first exposure to recursion gained a deeper understanding of recursion than students receiving a lecture-based introduction to recursion. Specifically, students who used the simulation required fewer attempts to complete a set of recursive programming exercises and performed better on a follow-up exam given six weeks after the experiment;This research concludes with a discussion of two important questions: How should students think about recursion and how do they think about recursion. The simulation\u27s strengths and shortcomings in fostering effective ways of thinking about recursion are also discussed