def create_domain(goal_facts): domain = make_domain() for fact in goal_facts: # TODO: consider removing this annoying check name = get_prefix(fact) parameters = ['?x{}'.format(i) for i in range(len(get_args(fact)))] add_predicate(domain, make_predicate(name, parameters)) return domain
def instantiate_optimizer_axioms(instantiated, domain, results): # Needed for instantiating axioms before adding stream action effects # Otherwise, FastDownward will prune these unreachable axioms # TODO: compute this first and then apply the eager actions stream_init = { fd_from_fact(result.stream_fact) for result in results if isinstance(result, StreamResult) } evaluations = list( map(evaluation_from_fd, stream_init | instantiated.atoms)) temp_domain = make_domain( predicates=[make_predicate(UNSATISFIABLE, [])], axioms=[ax for ax in domain.axioms if ax.name == UNSATISFIABLE]) temp_problem = get_problem(evaluations, Not((UNSATISFIABLE, )), temp_domain) # TODO: UNSATISFIABLE might be in atoms making the goal always infeasible with Verbose(): # TODO: the FastDownward instantiation prunes static preconditions use_fd = False if using_optimizers(results) else FD_INSTANTIATE new_instantiated = instantiate_task(task_from_domain_problem( temp_domain, temp_problem), use_fd=use_fd, check_infeasible=False, prune_static=False) assert new_instantiated is not None instantiated.axioms.extend(new_instantiated.axioms) instantiated.atoms.update(new_instantiated.atoms)
def add_stream_actions(domain, results, **kwargs): stream_actions, result_from_name = get_stream_actions(results, **kwargs) output_objects = [] for result in result_from_name.values(): if isinstance(result, StreamResult): output_objects.extend(map(pddl_from_object, result.output_objects)) new_constants = list( make_parameters(set(output_objects) | set(domain.constants))) # to_untyped_strips, free_variables new_domain = make_domain(constants=new_constants, predicates=domain.predicates, actions=domain.actions[:] + stream_actions, axioms=domain.axioms) #new_domain = copy.copy(domain) """ optimizer_results = list(filter(is_optimizer_result, stream_results)) optimizer_facts = {substitute_expression(result.external.stream_fact, result.get_mapping()) for result in optimizer_results} optimizers = {result.external.optimizer for result in optimizer_results} print(optimizers) for optimizer in optimizers: for stream in optimizer.streams: print(stream.instance.get_constraints()) print(stream.instance) #print(optimizer_results) #print(optimizer_facts) """ return new_domain, result_from_name
def add_stream_actions(domain, results, **kwargs): if not results: return domain, {} stream_actions, result_from_name = get_stream_actions(results, **kwargs) output_objects = [] for result in result_from_name.values(): if isinstance(result, StreamResult): output_objects.extend(map(pddl_from_object, result.output_objects)) new_constants = list(make_parameters(set(output_objects) | set(domain.constants))) # to_untyped_strips, free_variables new_domain = make_domain(constants=new_constants, predicates=domain.predicates, actions=domain.actions[:] + stream_actions, axioms=domain.axioms) #new_domain = copy.copy(domain) return new_domain, result_from_name
def planning_from_satisfaction(init, constraints): clusters = cluster_constraints(constraints) prefix = get_internal_prefix(internal=False) assigned_predicate = ASSIGNED_PREDICATE.format(prefix) order_predicate = ORDER_PREDICATE.format(prefix) #order_value_facts = make_order_facts(order_predicate, 0, len(clusters)+1) order_value_facts = [(order_predicate, '_t{}'.format(i)) for i in range(len(clusters) + 1)] init.append(order_value_facts[0]) goal_expression = order_value_facts[-1] order_facts = list(map(obj_from_value_expression, order_value_facts)) bound_parameters = set() actions = [] #constants = {} for i, cluster in enumerate(clusters): objectives = list(map(obj_from_value_expression, cluster.constraints)) constraints, negated, costs = partition_facts(objectives) if negated: raise NotImplementedError(negated) #free_parameters = cluster.parameters - bound_parameters existing_parameters = cluster.parameters & bound_parameters # TODO: confirm that negated predicates work as intended name = 'cluster-{}'.format(i) parameters = list(sorted(cluster.parameters)) preconditions = [(assigned_predicate, to_constant(p), p) for p in sorted(existing_parameters)] + \ constraints + [order_facts[i]] effects = [(assigned_predicate, to_constant(p), p) for p in parameters] + \ [order_facts[i+1], Not(order_facts[i])] if costs: assert len(costs) == 1 [cost] = costs else: cost = None actions.append( make_action(name, parameters, preconditions, effects, cost)) #actions[-1].dump() bound_parameters.update(cluster.parameters) predicates = [make_predicate(order_predicate, ['?step'])] # '?num', domain = make_domain(predicates=predicates, actions=actions) return domain, goal_expression
def planning_from_satisfaction(init, constraints): clusters = cluster_constraints(constraints) order_value_facts = [(ORDER_PREDICATE, 't{}'.format(i)) for i in range(len(clusters) + 1)] init.append(order_value_facts[0]) goal_expression = order_value_facts[-1] order_facts = list(map(obj_from_value_expression, order_value_facts)) bound_parameters = set() actions = [] #constants = {} for i, cluster in enumerate(clusters): objectives = list(map(obj_from_value_expression, cluster.constraints)) #free_parameters = cluster.parameters - bound_parameters existing_parameters = cluster.parameters & bound_parameters # TODO: confirm that negated predicates work as intended name = 'cluster-{}'.format(i) parameters = list(sorted(cluster.parameters)) preconditions = [(ASSIGNED_PREDICATE, to_constant(p), p) for p in sorted(existing_parameters)] + \ get_constraints(objectives) + [order_facts[i]] effects = [(ASSIGNED_PREDICATE, to_constant(p), p) for p in parameters] + \ [order_facts[i+1], Not(order_facts[i])] costs = get_costs(objectives) cost = None if costs: assert len(costs) == 1 cost = get_args(costs[0])[0] actions.append( make_action(name, parameters, preconditions, effects, cost)) #actions[-1].dump() bound_parameters.update(cluster.parameters) predicates = [make_predicate(ORDER_PREDICATE, ['?x'])] domain = make_domain(predicates=predicates, actions=actions) return domain, goal_expression