Add or remove goals from a PDDL problem.

[MannavaVivek]

I have a pddl file like so,

(define (problem general_domain_task-problem)
 (:domain general_domain_task-domain)
 (:objects
   sh01 cb01 ws01 ws02 start_ end_ - location
   youbot_brsu - robot
   r20 m20 m30_00 m30_01 axis bearing - robject
   platform_middle platform_left platform_right - robot_platform
 )
 (:init (at_ youbot_brsu start_) (gripper_is_free youbot_brsu) (on r20 sh01) (on bearing cb01) (on m30_00 ws01) (on m20 ws01) (on axis ws02) (on m30_01 ws01) (= (total-cost) 0))
 (:goal (and (on r20 ws01) (on axis ws01) (on m20 ws02) (on m30_00 ws02) (on bearing ws02)))
 (:metric minimize (total-cost))
)

I parse this into the format for UPF, use OneShotplanner with fast-downward and generate a plan. Suppose, when I am executing the plan with a robot and some issue occurs. I want to remove that specfic goal from that problem and use replanner to generate a new plan. How do I do the part where I remove the goal and replan? When I try to follow the example in the docs, it says "on" is not defined.

This is the generated upf problem file

types = [location, robot, robject, robot_platform, drawer]

fluents = [
  bool at[r=robot, l=location]
  bool on[o=robject, l=location]
  bool stored[o=robject, rp=robot_platform]
  bool occupied[rp=robot_platform]
  bool holding[r=robot, o=robject]
  bool gripper_is_free[r=robot]
  bool container[o=robject]
  bool in[peg=robject, hole=robject]
  bool heavy[o=robject]
  bool insertable[o=robject]
  bool perceived[l=location]
  bool opened[d=drawer]
  bool inside[o=robject, d=drawer]
  bool perceived_inside[d=drawer]
  bool located_at[d=drawer, l=location]
  bool is_large[o=robject]
  bool is_big_enough[rp=robot_platform]
]

actions = [
  action move_base(robot r, location source, location destination) {
    preconditions = [
      (at(r, source) and gripper_is_free(r))
    ]
    effects = [
      at(r, source) := false
      at(r, destination) := true
      perceived(source) := false
    ]
  }
  action perceive(robot r, location l) {
    preconditions = [
      (at(r, l) and gripper_is_free(r) and (not perceived(l)))
    ]
    effects = [
      perceived(l) := true
    ]
  }
  action pick(robot r, location l, robject o) {
    preconditions = [
      (on(o, l) and at(r, l) and perceived(l) and gripper_is_free(r) and (not holding(r, o)) and (not heavy(o)))
    ]
    effects = [
      holding(r, o) := true
      on(o, l) := false
      gripper_is_free(r) := false
    ]
  }
  action place(robot r, location l, robject o) {
    preconditions = [
      (at(r, l) and holding(r, o) and (not on(o, l)) and (not insertable(o)) and (not gripper_is_free(r)))
    ]
    effects = [
      on(o, l) := true
      holding(r, o) := false
      gripper_is_free(r) := true
      perceived(l) := false
    ]
  }
  action stage_general(robot r, robot_platform rp, robject o) {
    preconditions = [
      (holding(r, o) and (not occupied(rp)) and (not gripper_is_free(r)) and (not is_large(o)))
    ]
    effects = [
      holding(r, o) := false
      gripper_is_free(r) := true
      stored(o, rp) := true
      occupied(rp) := true
    ]
  }
  action stage_large(robot r, robot_platform rp, robject o) {
    preconditions = [
      (holding(r, o) and (not occupied(rp)) and (not gripper_is_free(r)) and is_big_enough(rp) and is_large(o))
    ]
    effects = [
      holding(r, o) := false
      gripper_is_free(r) := true
      stored(o, rp) := true
      occupied(rp) := true
    ]
  }
  action unstage(robot r, robot_platform rp, robject o) {
    preconditions = [
      (gripper_is_free(r) and stored(o, rp) and (not holding(r, o)))
    ]
    effects = [
      gripper_is_free(r) := false
      stored(o, rp) := false
      occupied(rp) := false
      holding(r, o) := true
    ]
  }
  action insert(robot r, robot_platform rp, location l, robject peg, robject hole) {
    preconditions = [
      (at(r, l) and on(hole, l) and container(hole) and (not holding(r, peg)) and gripper_is_free(r) and stored(peg, rp) and (not container(peg)))
    ]
    effects = [
      holding(r, peg) := false
      gripper_is_free(r) := true
      in(peg, hole) := true
      on(peg, l) := true
      stored(peg, rp) := false
      occupied(rp) := false
      heavy(hole) := true
      heavy(peg) := true
    ]
  }
  action open(robot r, location draw_loc, drawer d) {
    preconditions = [
      (at(r, draw_loc) and located_at(d, draw_loc) and perceived(draw_loc) and gripper_is_free(r) and (not opened(d)))
    ]
    effects = [
      opened(d) := true
      gripper_is_free(r) := true
    ]
  }
  action close(robot r, location draw_loc, drawer d) {
    preconditions = [
      (at(r, draw_loc) and located_at(d, draw_loc) and gripper_is_free(r) and opened(d))
    ]
    effects = [
      opened(d) := false
      gripper_is_free(r) := true
    ]
  }
  action perceive_inside_drawer(robot r, location draw_loc, drawer d) {
    preconditions = [
      (at(r, draw_loc) and located_at(d, draw_loc) and opened(d) and gripper_is_free(r) and (not perceived_inside(d)))
    ]
    effects = [
      perceived_inside(d) := true
    ]
  }
  action pick_from_drawer(robot r, location draw_loc, drawer d, robject o) {
    preconditions = [
      (inside(o, d) and at(r, draw_loc) and located_at(d, draw_loc) and perceived_inside(d) and gripper_is_free(r) and (not holding(r, o)) and (not heavy(o)) and opened(d))
    ]
    effects = [
      holding(r, o) := true
      inside(o, d) := false
      gripper_is_free(r) := false
    ]
  }
  action place_inside_drawer(robot r, location draw_loc, drawer d, robject o) {
    preconditions = [
      (at(r, draw_loc) and located_at(d, draw_loc) and holding(r, o) and perceived(draw_loc) and (not insertable(o)) and (not gripper_is_free(r)) and opened(d))
    ]
    effects = [
      inside(o, d) := true
      holding(r, o) := false
      gripper_is_free(r) := true
    ]
  }
]

objects = [
  location: [sh01, cb01, ws01, ws02, start, end]
  robot: [youbot-brsu]
  robject: [r20, m20, m30-00, m30-01, axis, bearing]
  robot_platform: [platform_middle, platform_left, platform_right]
  drawer: []
]

initial fluents default = [
  bool at[r=robot, l=location] := false
  bool on[o=robject, l=location] := false
  bool stored[o=robject, rp=robot_platform] := false
  bool occupied[rp=robot_platform] := false
  bool holding[r=robot, o=robject] := false
  bool gripper_is_free[r=robot] := false
  bool container[o=robject] := false
  bool in[peg=robject, hole=robject] := false
  bool heavy[o=robject] := false
  bool insertable[o=robject] := false
  bool perceived[l=location] := false
  bool opened[d=drawer] := false
  bool inside[o=robject, d=drawer] := false
  bool perceived_inside[d=drawer] := false
  bool located_at[d=drawer, l=location] := false
  bool is_large[o=robject] := false
  bool is_big_enough[rp=robot_platform] := false
]

initial values = [
  at(youbot-brsu, start) := true
  gripper_is_free(youbot-brsu) := true
  on(r20, sh01) := true
  on(bearing, cb01) := true
  on(m30-00, ws01) := true
  on(m20, ws01) := true
  on(axis, ws02) := true
  on(m30-01, ws01) := true
]

goals = [
  (on(r20, ws01) and on(axis, ws01) and on(m20, ws02) and on(m30-00, ws02) and on(bearing, ws02))
]

quality metrics = [
  minimize actions-cost: {'move_base': 20, 'perceive': 10, 'pick': 2, 'place': 2, 'stage_general': 1, 'stage_large': 1, 'unstage': 1, 'insert': 15, 'open': 2, 'close': 2, 'perceive_inside_drawer': 10, 'pick_from_drawer': 2, 'place_inside_drawer': 2, 'default': 0}
]

Here is the code I have so far

from unified_planning.io import PDDLReader, PDDLWriter
from unified_planning.shortcuts import *
from unified_planning.engines import PlanGenerationResultStatus
import unified_planning as up

up.shortcuts.get_environment().credits_stream = None

reader = PDDLReader()
problem = reader.parse_problem("domain.pddl", "smaller_problem.pddl")
# print(problem)

with OneshotPlanner(
    problem_kind=problem.kind,
    optimality_guarantee=PlanGenerationResultStatus.SOLVED_OPTIMALLY,
) as planner:
    final_report = planner.solve(problem)
    plan = final_report.plan
    # print(plan)


with Replanner(problem,name='replanner[fast-downward]') as replanner:
    replanner.remove_goal(on(r20, ws01))
    print(f"1) {replanner.resolve().plan.actions}")

[Framba-Luca]

Hi @MannavaVivek .

So, your issue of on not being defined comes from the fact that on is a python variable that is never assigned to anything. For this you have to add the code commented with [1] .

Then for the remove_goal method you will have another problem: the PDDLReader parses the goals as a unique one (which is a "big and"). You need to rewrite the single goal (which is an And) into more goals. For this you have to add the code commented with [2].

Here the new python code that should work.

from unified_planning.io import PDDLReader, PDDLWriter
from unified_planning.shortcuts import *
from unified_planning.engines import PlanGenerationResultStatus
import unified_planning as up

up.shortcuts.get_environment().credits_stream = None

reader = PDDLReader()
problem = reader.parse_problem("domain.pddl", "smaller_problem.pddl")

# [2], removing the and goals from the problem and add it's children
goals = problem.goals
problem.clear_goals()
for goal in goals:
    if goal.is_and():
        for g in goal.args:
            problem.add_goal(g)
    else:
        problem.add_goal(goal)
# [end 2]
# [1] Define on, r20 and ws01 python variables getting the correct python object from the problem
on = problem.fluent("on")
r20 = problem.object("r20")
ws01 = problem.object("ws01")
# [end 1]

# print(problem)

with OneshotPlanner(
    problem_kind=problem.kind,
    optimality_guarantee=PlanGenerationResultStatus.SOLVED_OPTIMALLY,
) as planner:
    final_report = planner.solve(problem)
    plan = final_report.plan
    # print(plan)


with Replanner(problem,name='replanner[fast-downward]') as replanner:
    replanner.remove_goal(on(r20, ws01))
    print(f"1) {replanner.resolve().plan.actions}")

This code should work. Let me know if you still have any issue!