I was playing recently with logical planning [1], and heuristics to determine what possible actions to explore. A heuristic that I happened upon, that worked qu

I was playing recently with logical planning [1], and heuristics to determine what possible actions to explore. A heuristic that I happened upon, that worked quite well, was to work backward from the desired solution and choose actions that reduced the requirements on the state of the world. The result was not plans that were optimal, but it found plans quite quickly. When I changed it to find optimal plans (essentially performing a reverse breadth-first search) then it did so, but instead of "finding" a solution it simply exhausted the space of actions and states. The algorithm stopped seeming intelligent, and merely felt thorough. I wonder if this is state-requirement-reducing heuristic is closer to the problem-solving approach we use. Not an approach where we understand the world thoroughly, but one where we make plans that require the least specificity of the state of the world. In part this is because our planning is iterative; given a goal: plan towards the goal, perform an action, observe the state, plan towards the goal, perform the next action. Unexpected effects are accounted for... eventually. And the result is often not optimal. Also logical planning does not introduce conditionals, even though our plans always contain conditionals. To use the Yale Shooting Problem [2], we might construct a higher-order action, like "shoot the turkey" – and implicit in this action is "if the gun is not loaded, load the gun, then shoot the turkey". Also "if the turkey has escaped, find the turkey, then shoot the turkey". If the turkey escapes while you are loading the gun, then perhaps a better plan would have included securing the turkey before loading the gun, but this is exactly the sort of mistake that humans make in their planning. With conditionals it's even easier to have actions that reduce the specificity of the requirements to achieve a goal. But the plans will probably not be optimal, but still they are resilient to a world with unintended consequences. [1] https://github.com/ianb/bitplanning https://github.com/ianb/bitplanning [2] https://en.wikipedia.org/wiki/Yale_shooting_problem https://en.wikipedia.org/wiki/Yale_shooting_problem