def is_solution(domain, evaluations, action_plan, goal_expression): task = task_from_domain_problem( domain, get_problem(evaluations, goal_expression, domain, unit_costs=True)) action_instances = get_action_instances( task, action_plan) + [get_goal_instance(task.goal)] #original_init = task.init task.init = set(task.init) for instance in action_instances: axiom_plan = extract_axiom_plan(task, instance, negative_from_name={}, static_state=task.init) if axiom_plan is None: return False #substitute_derived(axiom_plan, instance) #if not is_applicable(task.init, instance): # return False apply_action(task.init, instance) return True
def get_combined_orders(evaluations, stream_plan, action_plan, domain): if not is_plan(action_plan): return action_plan # TODO: could just do this within relaxed # TODO: do I want to strip the fluents and just do the partial ordering? stream_instances = get_stream_instances(stream_plan) negative_results = filter( lambda r: isinstance(r, PredicateResult) and (r.value == False), stream_plan) negative_init = set( fd_from_evaluation(evaluation_from_fact(f)) for r in negative_results for f in r.get_certified()) #negated_from_name = {r.instance.external.name for r in negative_results} opt_evaluations = evaluations_from_stream_plan(evaluations, stream_plan) goal_expression = And() task = task_from_domain_problem( domain, get_problem(opt_evaluations, goal_expression, domain, unit_costs=True)) action_instances = get_action_instances(task, action_plan) replace_derived(task, negative_init, action_instances) #combined_instances = stream_instances + action_instances orders = set() for i, a1 in enumerate(action_plan): for a2 in action_plan[i + 1:]: orders.add((a1, a2)) # TODO: just store first achiever here for i, instance1 in enumerate(stream_instances): for j in range(i + 1, len(stream_instances)): effects = {e for _, e in instance1.add_effects} if effects & set(stream_instances[j].precondition): orders.add((stream_plan[i], stream_plan[j])) for i, instance1 in enumerate(stream_instances): for j, instance2 in enumerate(action_instances): effects = {e for _, e in instance1.add_effects} | \ {e.negate() for _, e in instance1.del_effects} if effects & set(instance2.precondition): orders.add((stream_plan[i], action_plan[j])) return orders
def apply_actions(domain, state, plan, unit_costs=False): # Goal serialization just assumes the tail of the plan includes an abstract action to achieve each condition static_state, _ = partition_facts(domain, state) print('Static:', static_state) # TODO: might need properties that involve an object that aren't useful yet evaluations = evaluations_from_init(state) #goal_exp = obj_from_value_expression(goal) goal_exp = None problem = get_problem(evaluations, goal_exp, domain, unit_costs) task = task_from_domain_problem(domain, problem) task.init = set(task.init) for instance in get_action_instances( task, transform_plan_args(plan, Object.from_value)): apply_action(task.init, instance) fluents = get_fluents(domain) fluent_state = [ value_from_evaluation(evaluation_from_fd(atom)) for atom in task.init if isinstance(atom, pddl.Atom) and atom.predicate in fluents ] print('Fluent:', fluent_state) state = static_state + fluent_state return state
def recover_opt_stream_plan(evaluations, action_plan, task): plan_instances = get_action_instances(task, action_plan) + [get_goal_instance(task.goal)] replace_derived(task, set(), plan_instances) preimage = filter(lambda a: not a.negated, plan_preimage(plan_instances, [])) opt_stream_plan = [] opt_from_obj = {} for stream_result in extract_order(evaluations, preimage): input_objects = tuple(opt_from_obj.get(o, o) for o in stream_result.instance.input_objects) instance = stream_result.instance.external.get_instance(input_objects) #instance.opt_index = stream_result.instance.opt_index #assert(instance.opt_index == 0) instance.opt_index = 0 #assert(not instance.disabled) instance.disabled = False opt_results = instance.next_optimistic() if not opt_results: continue opt_result = opt_results[0] opt_stream_plan.append(opt_result) for obj, opt in zip(stream_result.output_objects, opt_result.output_objects): opt_from_obj[obj] = opt return opt_stream_plan, opt_from_obj