def pddl_to_sas(task): with timers.timing("Instantiating", block=True): (relaxed_reachable, atoms, actions, axioms, reachable_action_params) = instantiate.explore(task) if not relaxed_reachable: return unsolvable_sas_task("No relaxed solution") # HACK! Goals should be treated differently. if isinstance(task.goal, pddl.Conjunction): goal_list = task.goal.parts else: goal_list = [task.goal] for item in goal_list: assert isinstance(item, pddl.Literal) with timers.timing("Computing fact groups", block=True): groups, mutex_groups, translation_key = fact_groups.compute_groups( task, atoms, reachable_action_params, partial_encoding=USE_PARTIAL_ENCODING) with timers.timing("Building STRIPS to SAS dictionary"): ranges, strips_to_sas = strips_to_sas_dictionary( groups, assert_partial=USE_PARTIAL_ENCODING) with timers.timing("Building dictionary for full mutex groups"): mutex_ranges, mutex_dict = strips_to_sas_dictionary( mutex_groups, assert_partial=False) if ADD_IMPLIED_PRECONDITIONS: with timers.timing("Building implied facts dictionary..."): implied_facts = build_implied_facts(strips_to_sas, groups, mutex_groups) else: implied_facts = {} with timers.timing("Building mutex information", block=True): mutex_key = build_mutex_key(strips_to_sas, mutex_groups) with timers.timing("Translating task", block=True): sas_task = translate_task( strips_to_sas, ranges, translation_key, mutex_dict, mutex_ranges, mutex_key, task.init, goal_list, actions, axioms, task.use_min_cost_metric, implied_facts) print("%d implied effects removed" % removed_implied_effect_counter) print("%d effect conditions simplified" % simplified_effect_condition_counter) print("%d implied preconditions added" % added_implied_precondition_counter) if DETECT_UNREACHABLE: with timers.timing("Detecting unreachable propositions", block=True): try: simplify.filter_unreachable_propositions(sas_task) except simplify.Impossible: return unsolvable_sas_task("Simplified to trivially false goal") return sas_task
def pddl_to_sas(task): with timers.timing("Instantiating", block=True): (relaxed_reachable, atoms, actions, axioms, reachable_action_params) = instantiate.explore(task) if not relaxed_reachable: return unsolvable_sas_task("No relaxed solution") # HACK! Goals should be treated differently. if isinstance(task.goal, pddl.Conjunction): goal_list = task.goal.parts else: goal_list = [task.goal] for item in goal_list: assert isinstance(item, pddl.Literal) with timers.timing("Computing fact groups", block=True): groups, mutex_groups, translation_key = fact_groups.compute_groups( task, atoms, reachable_action_params) with timers.timing("Building STRIPS to SAS dictionary"): ranges, strips_to_sas = strips_to_sas_dictionary( groups, assert_partial=options.use_partial_encoding) with timers.timing("Building dictionary for full mutex groups"): mutex_ranges, mutex_dict = strips_to_sas_dictionary( mutex_groups, assert_partial=False) if options.add_implied_preconditions: with timers.timing("Building implied facts dictionary..."): implied_facts = build_implied_facts(strips_to_sas, groups, mutex_groups) else: implied_facts = {} with timers.timing("Building mutex information", block=True): mutex_key = build_mutex_key(strips_to_sas, mutex_groups) with timers.timing("Translating task", block=True): sas_task = translate_task( strips_to_sas, ranges, translation_key, mutex_dict, mutex_ranges, mutex_key, task.init, goal_list, actions, axioms, task.use_min_cost_metric, implied_facts) print("%d effect conditions simplified" % simplified_effect_condition_counter) print("%d implied preconditions added" % added_implied_precondition_counter) if options.filter_unreachable_facts: with timers.timing("Detecting unreachable propositions", block=True): try: simplify.filter_unreachable_propositions(sas_task) except simplify.Impossible: return unsolvable_sas_task("Simplified to trivially false goal") except simplify.TriviallySolvable: return solvable_sas_task("Simplified to empty goal") return sas_task
def pddl_to_sas(task): with timers.timing("Instantiating", block=True): relaxed_reachable, atoms, actions, axioms = instantiate.explore(task) if not relaxed_reachable: return unsolvable_sas_task("No relaxed solution") # HACK! Goals should be treated differently. if isinstance(task.goal, pddl.Conjunction): goal_list = task.goal.parts else: goal_list = [task.goal] for item in goal_list: assert isinstance(item, pddl.Literal) with timers.timing("Computing fact groups", block=True): groups, mutex_groups, translation_key = fact_groups.compute_groups( task, atoms, partial_encoding=USE_PARTIAL_ENCODING) with timers.timing("Building STRIPS to SAS dictionary"): ranges, strips_to_sas = strips_to_sas_dictionary( groups, assert_partial=USE_PARTIAL_ENCODING) with timers.timing("Building dictionary for full mutex groups"): mutex_ranges, mutex_dict = strips_to_sas_dictionary( mutex_groups, assert_partial=False) if ADD_IMPLIED_PRECONDITIONS: with timers.timing("Building implied facts dictionary..."): implied_facts = build_implied_facts(strips_to_sas, groups, mutex_groups) else: implied_facts = {} with timers.timing("Translating task", block=True): sas_task = translate_task( strips_to_sas, ranges, mutex_dict, mutex_ranges, task.init, goal_list, actions, axioms, task.use_min_cost_metric, implied_facts) print "%d implied effects removed" % removed_implied_effect_counter print "%d effect conditions simplified" % simplified_effect_condition_counter print "%d implied preconditions added" % added_implied_precondition_counter with timers.timing("Building mutex information"): mutex_key = build_mutex_key(strips_to_sas, mutex_groups) if DETECT_UNREACHABLE: with timers.timing("Detecting unreachable propositions", block=True): try: simplify.filter_unreachable_propositions( sas_task, mutex_key, translation_key) except simplify.Impossible: return unsolvable_sas_task("Simplified to trivially false goal") with timers.timing("Writing translation key"): write_translation_key(translation_key) with timers.timing("Writing mutex key"): write_mutex_key(mutex_key) return sas_task
def sas_from_instantiated(instantiated_task): import timers import fact_groups import options import simplify import variable_order from translate import translate_task, unsolvable_sas_task, strips_to_sas_dictionary, \ build_implied_facts, build_mutex_key, solvable_sas_task if not instantiated_task: return unsolvable_sas_task("No relaxed solution") task, atoms, actions, axioms, reachable_action_params, goal_list = instantiated_task with timers.timing("Computing fact groups", block=True): groups, mutex_groups, translation_key = fact_groups.compute_groups( task, atoms, reachable_action_params) with timers.timing("Building STRIPS to SAS dictionary"): ranges, strips_to_sas = strips_to_sas_dictionary( groups, assert_partial=options.use_partial_encoding) with timers.timing("Building dictionary for full mutex groups"): mutex_ranges, mutex_dict = strips_to_sas_dictionary( mutex_groups, assert_partial=False) if options.add_implied_preconditions: with timers.timing("Building implied facts dictionary..."): implied_facts = build_implied_facts(strips_to_sas, groups, mutex_groups) else: implied_facts = {} with timers.timing("Building mutex information", block=True): mutex_key = build_mutex_key(strips_to_sas, mutex_groups) with timers.timing("Translating task", block=True): sas_task = translate_task(strips_to_sas, ranges, translation_key, mutex_dict, mutex_ranges, mutex_key, task.init, goal_list, actions, axioms, task.use_min_cost_metric, implied_facts) if options.filter_unreachable_facts: with timers.timing("Detecting unreachable propositions", block=True): try: simplify.filter_unreachable_propositions(sas_task) except simplify.Impossible: return unsolvable_sas_task( "Simplified to trivially false goal") except simplify.TriviallySolvable: return solvable_sas_task("Simplified to empty goal") if options.reorder_variables or options.filter_unimportant_vars: with timers.timing("Reordering and filtering variables", block=True): variable_order.find_and_apply_variable_order( sas_task, options.reorder_variables, options.filter_unimportant_vars) translate.dump_statistics(sas_task) return sas_task
def pddl_to_sas_lite(task, actions, relaxed_reachable, atoms, axioms, reachable_action_params): # HACK! Goals should be treated differently. if isinstance(task.goal, pddl.Conjunction): goal_list = task.goal.parts else: goal_list = [task.goal] #print ("Goals "+str(goal_list)) for item in goal_list: assert isinstance(item, pddl.Literal) with timers.timing("Computing fact groups", block=True): groups, mutex_groups, translation_key = fact_groups.compute_groups( task, atoms, reachable_action_params) with timers.timing("Building STRIPS to SAS dictionary"): ranges, strips_to_sas = strips_to_sas_dictionary( groups, assert_partial=options.use_partial_encoding) with timers.timing("Building dictionary for full mutex groups"): mutex_ranges, mutex_dict = strips_to_sas_dictionary( mutex_groups, assert_partial=False) if options.add_implied_preconditions: with timers.timing("Building implied facts dictionary..."): implied_facts = build_implied_facts(strips_to_sas, groups, mutex_groups) else: implied_facts = {} with timers.timing("Building mutex information", block=True): mutex_key = build_mutex_key(strips_to_sas, mutex_groups) with timers.timing("Translating task", block=True): sas_task = translate_task(strips_to_sas, ranges, translation_key, mutex_dict, mutex_ranges, mutex_key, task.init, goal_list, actions, axioms, task.use_min_cost_metric, implied_facts) print("%d effect conditions simplified" % simplified_effect_condition_counter) print("%d implied preconditions added" % added_implied_precondition_counter) #print ("Goals init "+str(sas_task.init.values)) #print ("Goals pair "+str(sas_task.goal.pairs)) if options.filter_unreachable_facts: with timers.timing("Detecting unreachable propositions", block=True): try: simplify.filter_unreachable_propositions(sas_task) except simplify.Impossible: #print ("Goals IMPOSSIBLE") return unsolvable_sas_task( "Simplified to trivially false goal") #print ("Goals pair "+str(sas_task.goal.pairs)) return sas_task
def pddl_to_sas(task): print "Instantiating..." relaxed_reachable, atoms, actions, axioms = instantiate.explore(task) if not relaxed_reachable: return unsolvable_sas_task("No relaxed solution") # HACK! Goals should be treated differently (see TODO file). if isinstance(task.goal, pddl.Conjunction): goal_list = task.goal.parts else: goal_list = [task.goal] for item in goal_list: assert isinstance(item, pddl.Literal) groups, mutex_groups, translation_key = fact_groups.compute_groups( task, atoms, return_mutex_groups=WRITE_ALL_MUTEXES, partial_encoding=USE_PARTIAL_ENCODING) print "Building STRIPS to SAS dictionary..." ranges, strips_to_sas = strips_to_sas_dictionary(groups) print "Translating task..." sas_task = translate_task(strips_to_sas, ranges, task.init, goal_list, actions, axioms, task.use_min_cost_metric) mutex_key = build_mutex_key(strips_to_sas, mutex_groups) try: simplify.filter_unreachable_propositions(sas_task, mutex_key, translation_key) except simplify.Impossible: return unsolvable_sas_task("Simplified to trivially false goal") write_translation_key(translation_key) if WRITE_ALL_MUTEXES: write_mutex_key(mutex_key) return sas_task
def pddl_to_sas(task): print "Instantiating..." relaxed_reachable, atoms, actions, axioms = instantiate.explore(task) if not relaxed_reachable: return unsolvable_sas_task("No relaxed solution") # HACK! Goals should be treated differently (see TODO file). if isinstance(task.goal, pddl.Conjunction): goal_list = task.goal.parts else: goal_list = [task.goal] for item in goal_list: assert isinstance(item, pddl.Literal) # groups, mutex_groups, translation_key = fact_groups.compute_groups( # task, atoms, return_mutex_groups=WRITE_ALL_MUTEXES, # partial_encoding=USE_PARTIAL_ENCODING) # switched off invariant syntheses -> one group for each fluent fact groups = [[fact] for fact in atoms] translation_key = [[str(fact),str(fact.negate())] for group in groups for fact in group] print "Building STRIPS to SAS dictionary..." ranges, strips_to_sas = strips_to_sas_dictionary(groups) print "Translating task..." sas_task = translate_task(strips_to_sas, ranges, task.init, goal_list, actions, axioms) try: simplify.filter_unreachable_propositions( sas_task, [], translation_key) except simplify.Impossible: return unsolvable_sas_task("Simplified to trivially false goal") write_translation_key(translation_key) return sas_task
def pddl_to_sas(task): print("Instantiating...") relaxed_reachable, atoms, actions, axioms, _ = instantiate.explore(task) if not relaxed_reachable: return unsolvable_sas_task("No relaxed solution") # HACK! Goals should be treated differently (see TODO file). if isinstance(task.goal, pddl.Conjunction): goal_list = task.goal.parts else: goal_list = [task.goal] for item in goal_list: assert isinstance(item, pddl.Literal) # switched off invariant syntheses -> one group for each fluent fact groups = [[fact] for fact in atoms] mutex_groups = [] translation_key = [[str(fact), str(fact.negate())] for group in groups for fact in group] print("Building STRIPS to SAS dictionary...") ranges, strips_to_sas = strips_to_sas_dictionary(groups) print("Building mutex information...") mutex_key = build_mutex_key(strips_to_sas, mutex_groups) print("Translating task...") sas_task = translate_task(strips_to_sas, ranges, translation_key, mutex_key, task.init, goal_list, actions, axioms, task.use_min_cost_metric) try: simplify.filter_unreachable_propositions(sas_task) except simplify.Impossible: return unsolvable_sas_task("Simplified to trivially false goal") return sas_task
def pddl_to_sas(task): print("Instantiating...") relaxed_reachable, atoms, actions, axioms, _ = instantiate.explore(task) if not relaxed_reachable: return unsolvable_sas_task("No relaxed solution") # HACK! Goals should be treated differently (see TODO file). if isinstance(task.goal, pddl.Conjunction): goal_list = task.goal.parts else: goal_list = [task.goal] for item in goal_list: assert isinstance(item, pddl.Literal) # switched off invariant syntheses -> one group for each fluent fact groups = [[fact] for fact in atoms] mutex_groups = [] translation_key = [[str(fact),str(fact.negate())] for group in groups for fact in group] print("Building STRIPS to SAS dictionary...") ranges, strips_to_sas = strips_to_sas_dictionary(groups) print("Building mutex information...") mutex_key = build_mutex_key(strips_to_sas, mutex_groups) print("Translating task...") sas_task = translate_task(strips_to_sas, ranges, translation_key, mutex_key, task.init, goal_list, actions, axioms, task.use_min_cost_metric) try: simplify.filter_unreachable_propositions(sas_task) except simplify.Impossible: return unsolvable_sas_task("Simplified to trivially false goal") return sas_task
def pddl_to_sas(task): print "Instantiating..." relaxed_reachable, atoms, actions, axioms = instantiate.explore(task) if not relaxed_reachable: return unsolvable_sas_task("No relaxed solution") # HACK! Goals should be treated differently (see TODO file). if isinstance(task.goal, pddl.Conjunction): goal_list = task.goal.parts else: goal_list = [task.goal] for item in goal_list: assert isinstance(item, pddl.Literal) # groups, mutex_groups, translation_key = fact_groups.compute_groups( # task, atoms, return_mutex_groups=WRITE_ALL_MUTEXES, # partial_encoding=USE_PARTIAL_ENCODING) # switched off invariant syntheses -> one group for each fluent fact groups = [[fact] for fact in atoms] translation_key = [[str(fact), str(fact.negate())] for group in groups for fact in group] print "Building STRIPS to SAS dictionary..." ranges, strips_to_sas = strips_to_sas_dictionary(groups) print "Translating task..." sas_task = translate_task(strips_to_sas, ranges, task.init, goal_list, actions, axioms) try: simplify.filter_unreachable_propositions(sas_task, [], translation_key) except simplify.Impossible: return unsolvable_sas_task("Simplified to trivially false goal") write_translation_key(translation_key) return sas_task
def pddl_to_sas(task): print "Instantiating..." relaxed_reachable, atoms, actions, axioms = instantiate.explore(task) if not relaxed_reachable: return unsolvable_sas_task("No relaxed solution") # HACK! Goals should be treated differently (see TODO file). if isinstance(task.goal, pddl.Conjunction): goal_list = task.goal.parts else: goal_list = [task.goal] for item in goal_list: assert isinstance(item, pddl.Literal) groups, mutex_groups, translation_key = fact_groups.compute_groups( task, atoms, return_mutex_groups=WRITE_ALL_MUTEXES, partial_encoding=USE_PARTIAL_ENCODING) print "Building STRIPS to SAS dictionary..." ranges, strips_to_sas = strips_to_sas_dictionary(groups) print "Translating task..." sas_task = translate_task(strips_to_sas, ranges, task.init, goal_list, actions, axioms, task.use_min_cost_metric) mutex_key = build_mutex_key(strips_to_sas, mutex_groups) try: simplify.filter_unreachable_propositions( sas_task, mutex_key, translation_key) except simplify.Impossible: return unsolvable_sas_task("Simplified to trivially false goal") write_translation_key(translation_key) if WRITE_ALL_MUTEXES: write_mutex_key(mutex_key) return sas_task
def pddl_to_sas(task): with timers.timing("Instantiating", block=True): (relaxed_reachable, atoms, num_fluents, actions, axioms, num_axioms, init_constant_predicates, init_constant_numerics, reachable_action_params) = instantiate.explore(task) if DEBUG: print("Task converted to SAS.") # task.function_administrator.dump() if DEBUG: print("Relaxed_reachable: %s" % relaxed_reachable) if DEBUG: print("List of %d Atoms:" % len(atoms)) # for atom in atoms: # atom.dump() if DEBUG: print("List of %d numeric Fluents:" % len(num_fluents)) # for fluent in num_fluents: # fluent.dump() if len(num_fluents) == 0: assert False if DEBUG: print("List of %d Actions:" % len(actions)) # for action in actions: # print(action.name) if DEBUG: print("List of %d propositional Axioms:" % len(axioms)) # if len(axioms) > 0: # axioms[0].dump() # print("layer=%s"%axioms[0].__class__ ) # for axiom in axioms: # axiom.dump() if DEBUG: print("List of %d numeric Axioms:" % len(num_axioms)) # for numax in num_axioms: # numax.dump() if DEBUG: print("List of %d constant predicates from initial state" % len(init_constant_predicates)) # for icp in init_constant_predicates: # icp.dump() if DEBUG: print("List of %d constant numeric predicates from initial state" % len(init_constant_numerics)) # for icn in init_constant_numerics: # icn.dump() if DEBUG: print("List of %d reachable Action Parameters:" % len(reachable_action_params)) # for rap in reachable_action_params: # rap.dump() if not relaxed_reachable: return unsolvable_sas_task("No relaxed solution") # HACK! Goals should be treated differently. if isinstance(task.goal, pddl.Conjunction): goal_list = task.goal.parts else: goal_list = [task.goal] for item in goal_list: assert isinstance(item, pddl.Literal) assert isinstance(task.global_constraint, pddl.Literal) # if DEBUG: print("Global constraint Literal is ", task.global_constraint) with timers.timing("Computing fact groups", block=True): # groups: the ground facts are grouped in order to create multi valued variables # mutex_groups: includes all mutex groups, so a fact can appear in multiple groups # translation key: the names of the grounded facts of the MVV determined in groups, including "NegatedAtom" for binary and "none of those" for multi valued variables groups, mutex_groups, translation_key = fact_groups.compute_groups( task, atoms, reachable_action_params) # print ("Fact groups (%d) computed %s" % (len(groups),[len(group) for group in groups])) # print ("Full mutex groups (%d) containing %s:" % (len(mutex_groups),[len(group) for group in mutex_groups])) with timers.timing("Handling numeric axioms"): num_axioms_by_layer, max_num_layer, num_axiom_map, const_num_axioms = \ numeric_axiom_rules.handle_axioms(num_axioms) with timers.timing("Building STRIPS to SAS dictionary"): ranges, strips_to_sas, num_count, numeric_strips_to_sas = strips_to_sas_dictionary( groups, num_axioms, num_axiom_map, num_fluents, assert_partial=options.use_partial_encoding) # if DEBUG: # print("Strips to sas dictionary (%s entries)" % len(strips_to_sas)) # for entry in sorted(strips_to_sas.items(), key=lambda x:x[1]): # sort by value # print("%s -> %s" % entry) # print(ranges) # print("Numeric Strips to sas dictionary (%s entries)" % len(numeric_strips_to_sas)) # for entry in numeric_strips_to_sas: # print("%s -> %s" % (entry, numeric_strips_to_sas[entry])) # print ("pddl2sas Zwischendebug: metric = ", task.metric) # assert task.metric[1] in numeric_strips_to_sas with timers.timing("Building dictionary for full mutex groups"): mutex_ranges, mutex_dict, _, _ = strips_to_sas_dictionary( mutex_groups, num_axioms, num_axiom_map, num_fluents, assert_partial=False, include_numeric=False) if options.add_implied_preconditions: with timers.timing("Building implied facts dictionary..."): implied_facts = build_implied_facts(strips_to_sas, groups, mutex_groups) else: implied_facts = {} with timers.timing("Building mutex information", block=True): mutex_key = build_mutex_key(strips_to_sas, mutex_groups) with timers.timing("Translating task", block=True): sas_task = translate_task( strips_to_sas, ranges, translation_key, numeric_strips_to_sas, num_count, mutex_dict, mutex_ranges, mutex_key, task.init, task.num_init, goal_list, task.global_constraint, actions, axioms, num_axioms, num_axioms_by_layer, num_axiom_map, const_num_axioms, task.metric, implied_facts, init_constant_predicates, init_constant_numerics) # print("len(variables.valuenames) = %s" % len(sas_task.variables.value_names)) print("%d effect conditions simplified" % simplified_effect_condition_counter) print("%d implied preconditions added" % added_implied_precondition_counter) # print("created sas_task") # sas_task.dump() if options.filter_unreachable_facts: with timers.timing("Detecting unreachable propositions", block=True): try: simplify.filter_unreachable_propositions(sas_task) except simplify.Impossible: return unsolvable_sas_task( "Simplified to trivially false goal") except simplify.TriviallySolvable: return solvable_sas_task("Simplified to empty goal") # print("translate pddl to sas returns task") return sas_task
def pddl_to_sas(task): # for partial observability assume that unknown facts # are true initially (to use it in the reachability analysis) mod_task = deepcopy(task) mod_task.init = mod_task.init + mod_task.init_unknown with timers.timing("Instantiating", block=True): (relaxed_reachable, atoms, actions, observation_actions, axioms, reachable_action_params) = instantiate.explore(mod_task) if not relaxed_reachable: # POND we return no unsolvable task return # HACK! Goals should be treated differently. if isinstance(task.goal, pddl.Conjunction): goal_list = task.goal.parts else: goal_list = [task.goal] for item in goal_list: assert isinstance(item, pddl.Literal) with timers.timing("Computing fact groups", block=True): groups, mutex_groups, translation_key = fact_groups.compute_groups( mod_task, atoms, reachable_action_params, partial_encoding=USE_PARTIAL_ENCODING) with timers.timing("Building STRIPS to SAS dictionary"): ranges, strips_to_sas = strips_to_sas_dictionary( groups, assert_partial=USE_PARTIAL_ENCODING) with timers.timing("Building dictionary for full mutex groups"): mutex_ranges, mutex_dict = strips_to_sas_dictionary( mutex_groups, assert_partial=False) if ADD_IMPLIED_PRECONDITIONS: with timers.timing("Building implied facts dictionary..."): implied_facts = build_implied_facts(strips_to_sas, groups, mutex_groups) else: implied_facts = {} with timers.timing("Building mutex information", block=True): mutex_key = build_mutex_key(strips_to_sas, mutex_groups) with timers.timing("Translating task", block=True): sas_task = translate_task( strips_to_sas, ranges, translation_key, mutex_dict, mutex_ranges, mutex_key, task.init, task.init_unknown, task.init_oneof, task.init_formula, goal_list, actions, observation_actions, axioms, task.use_min_cost_metric, implied_facts) print("%d effect conditions simplified" % simplified_effect_condition_counter) print("%d implied preconditions added" % added_implied_precondition_counter) if DETECT_UNREACHABLE: with timers.timing("Detecting unreachable propositions", block=True): try: simplify.filter_unreachable_propositions(sas_task) except simplify.Impossible: return unsolvable_sas_task("Simplified to trivially false goal") return sas_task
def pddl_to_sas(task): with timers.timing("Instantiating", block=True): (relaxed_reachable, atoms, actions, axioms, reachable_action_params) = instantiate.explore(task) if not relaxed_reachable: return unsolvable_sas_task("No relaxed solution") # HACK! Goals should be treated differently. if isinstance(task.goal, pddl.Conjunction): goal_list = task.goal.parts else: goal_list = [task.goal] for item in goal_list: assert isinstance(item, pddl.Literal) with timers.timing("Computing fact groups", block=True): groups, mutex_groups, translation_key = fact_groups.compute_groups( task, atoms, reachable_action_params) with timers.timing("Building STRIPS to SAS dictionary"): ranges, strips_to_sas = strips_to_sas_dictionary( groups, assert_partial=options.use_partial_encoding) with timers.timing("Building dictionary for full mutex groups"): mutex_ranges, mutex_dict = strips_to_sas_dictionary( mutex_groups, assert_partial=False) if options.add_implied_preconditions: with timers.timing("Building implied facts dictionary..."): implied_facts = build_implied_facts(strips_to_sas, groups, mutex_groups) else: implied_facts = {} with timers.timing("Building mutex information", block=True): if options.use_partial_encoding: mutex_key = build_mutex_key(strips_to_sas, mutex_groups) else: # With our current representation, emitting complete mutex # information for the full encoding can incur an # unacceptable (quadratic) blowup in the task representation # size. See issue771 for details. print( "using full encoding: between-variable mutex information skipped." ) mutex_key = [] with timers.timing("Translating task", block=True): sas_task = translate_task(strips_to_sas, ranges, translation_key, mutex_dict, mutex_ranges, mutex_key, task.init, goal_list, actions, axioms, task.use_min_cost_metric, implied_facts) print("%d effect conditions simplified" % simplified_effect_condition_counter) print("%d implied preconditions added" % added_implied_precondition_counter) if options.filter_unreachable_facts: with timers.timing("Detecting unreachable propositions", block=True): try: simplify.filter_unreachable_propositions(sas_task) except simplify.Impossible: return unsolvable_sas_task( "Simplified to trivially false goal") except simplify.TriviallySolvable: return solvable_sas_task("Simplified to empty goal") if options.reorder_variables or options.filter_unimportant_vars: with timers.timing("Reordering and filtering variables", block=True): variable_order.find_and_apply_variable_order( sas_task, options.reorder_variables, options.filter_unimportant_vars) return sas_task
def pddl_to_sas(task): with timers.timing("Instantiating", block=True): (relaxed_reachable, atoms, actions, axioms, reachable_action_params) = instantiate.explore(task) if not relaxed_reachable: return unsolvable_sas_task("No relaxed solution") goal_list = translate_to_list(task.goal) online_goals_list = [translate_to_list(subgoal) for subgoal in task.online_goals] online_goals_availability = task.online_goals_availability with timers.timing("Computing fact groups", block=True): groups, mutex_groups, translation_key = fact_groups.compute_groups( task, atoms, reachable_action_params) with timers.timing("Building STRIPS to SAS dictionary"): ranges, strips_to_sas = strips_to_sas_dictionary( groups, assert_partial=options.use_partial_encoding) with timers.timing("Building dictionary for full mutex groups"): mutex_ranges, mutex_dict = strips_to_sas_dictionary( mutex_groups, assert_partial=False) if options.add_implied_preconditions: with timers.timing("Building implied facts dictionary..."): implied_facts = build_implied_facts(strips_to_sas, groups, mutex_groups) else: implied_facts = {} with timers.timing("Building mutex information", block=True): mutex_key = build_mutex_key(strips_to_sas, mutex_groups) with timers.timing("Translating task", block=True): sas_task = translate_task( strips_to_sas, ranges, translation_key, mutex_dict, mutex_ranges, mutex_key, task.init, goal_list, online_goals_list, online_goals_availability, actions, axioms, task.use_min_cost_metric, task.execution_time, implied_facts) print("%d effect conditions simplified" % simplified_effect_condition_counter) print("%d implied preconditions added" % added_implied_precondition_counter) if options.filter_unreachable_facts: with timers.timing("Detecting unreachable propositions", block=True): try: simplify.filter_unreachable_propositions(sas_task) except simplify.Impossible: return unsolvable_sas_task("Simplified to trivially false goal") except simplify.TriviallySolvable: return solvable_sas_task("Simplified to empty goal") if options.reorder_variables or options.filter_unimportant_vars: with timers.timing("Reordering and filtering variables", block=True): variable_order.find_and_apply_variable_order( sas_task, options.reorder_variables, options.filter_unimportant_vars) return sas_task
def pddl_to_sas(task): with timers.timing("Instantiating", block=True): (relaxed_reachable, atoms, actions, axioms, reachable_action_params) = instantiate.explore(task) #if not relaxed_reachable: #return unsolvable_sas_task("No relaxed solution") # ALBERTO POZANCO # Here we write the static predicates outfile = open('static-predicates.txt', 'w+') for a in task.init: if type(a) is pddl.Atom and str(a.predicate) != '=': if a not in atoms: data = '(' + a.key[0] for x in a.key[1]: data += ' ' + str(x) data += ')' outfile.write(data + '\n') outfile.close() # HACK! Goals should be treated differently. if isinstance(task.goal, pddl.Conjunction): goal_list = task.goal.parts else: goal_list = [task.goal] for item in goal_list: assert isinstance(item, pddl.Literal) with timers.timing("Computing fact groups", block=True): groups, mutex_groups, translation_key = fact_groups.compute_groups( task, atoms, reachable_action_params) with timers.timing("Building STRIPS to SAS dictionary"): ranges, strips_to_sas = strips_to_sas_dictionary( groups, assert_partial=options.use_partial_encoding) with timers.timing("Building dictionary for full mutex groups"): mutex_ranges, mutex_dict = strips_to_sas_dictionary( mutex_groups, assert_partial=False) if options.add_implied_preconditions: with timers.timing("Building implied facts dictionary..."): implied_facts = build_implied_facts(strips_to_sas, groups, mutex_groups) else: implied_facts = {} with timers.timing("Building mutex information", block=True): mutex_key = build_mutex_key(strips_to_sas, mutex_groups) with timers.timing("Translating task", block=True): sas_task = translate_task(strips_to_sas, ranges, translation_key, mutex_dict, mutex_ranges, mutex_key, task.init, goal_list, actions, axioms, task.use_min_cost_metric, implied_facts) print("%d effect conditions simplified" % simplified_effect_condition_counter) print("%d implied preconditions added" % added_implied_precondition_counter) if options.filter_unreachable_facts: with timers.timing("Detecting unreachable propositions", block=True): try: simplify.filter_unreachable_propositions(sas_task) except simplify.Impossible: return unsolvable_sas_task( "Simplified to trivially false goal") except simplify.TriviallySolvable: return solvable_sas_task("Simplified to empty goal") if options.reorder_variables or options.filter_unimportant_vars: with timers.timing("Reordering and filtering variables", block=True): variable_order.find_and_apply_variable_order( sas_task, options.reorder_variables, options.filter_unimportant_vars) return sas_task
def pddl_to_sas(task, agent_id, agent_url): comm = None if agent_id >= 0 and len(agent_url) > 1: comm = AgentComm(agent_id, agent_url) with timers.timing("Instantiating", block=True): (relaxed_reachable, atoms, actions, axioms, reachable_action_params) = instantiate.explore(task, comm) if not relaxed_reachable: return unsolvable_sas_task("No relaxed solution") # HACK! Goals should be treated differently. if isinstance(task.goal, pddl.Conjunction): goal_list = task.goal.parts else: goal_list = [task.goal] for item in goal_list: assert isinstance(item, pddl.Literal) with timers.timing("Computing fact groups", block=True): groups, mutex_groups, translation_key = fact_groups.compute_groups( task, atoms, reachable_action_params, partial_encoding=USE_PARTIAL_ENCODING, comm = comm) with timers.timing("Building STRIPS to SAS dictionary"): ranges, strips_to_sas = strips_to_sas_dictionary( groups, assert_partial=USE_PARTIAL_ENCODING) if comm is not None: # Each group contains either all public or all private values private_vars = [x[0].is_private for x in groups] else: private_vars = [None for _ in groups] with timers.timing("Building dictionary for full mutex groups"): mutex_ranges, mutex_dict = strips_to_sas_dictionary( mutex_groups, assert_partial=False) if ADD_IMPLIED_PRECONDITIONS: with timers.timing("Building implied facts dictionary..."): implied_facts = build_implied_facts(strips_to_sas, groups, mutex_groups) else: implied_facts = {} with timers.timing("Building mutex information", block=True): mutex_key = build_mutex_key(strips_to_sas, mutex_groups) with timers.timing("Translating task", block=True): sas_task = translate_task( strips_to_sas, ranges, translation_key, private_vars, mutex_dict, mutex_ranges, mutex_key, task.init, goal_list, actions, axioms, task.use_min_cost_metric, implied_facts, task.agents, comm) print("%d effect conditions simplified" % simplified_effect_condition_counter) print("%d implied preconditions added" % added_implied_precondition_counter) if comm is not None: comm.close() if DETECT_UNREACHABLE and comm is None: with timers.timing("Detecting unreachable propositions", block=True): try: simplify.filter_unreachable_propositions(sas_task) except simplify.Impossible: return unsolvable_sas_task("Simplified to trivially false goal") return sas_task
def pddl_to_sas(task): with timers.timing("Instantiating", block=True): (relaxed_reachable, atoms, actions, axioms, reachable_action_params) = instantiate.explore(task) if not relaxed_reachable: return unsolvable_sas_task("No relaxed solution") # HACK! Goals should be treated differently. if isinstance(task.goal, pddl.Conjunction): goal_list = task.goal.parts else: goal_list = [task.goal] for item in goal_list: assert isinstance(item, pddl.Literal) with timers.timing("Computing fact groups", block=True): groups, mutex_groups, translation_key, inessentials = fact_groups.compute_groups( task, atoms, reachable_action_params, actions, axioms) with timers.timing("Building STRIPS to SAS dictionary"): ranges, strips_to_sas = strips_to_sas_dictionary( groups, assert_partial=options.use_partial_encoding) with timers.timing("Building dictionary for full mutex groups"): mutex_ranges, mutex_dict = strips_to_sas_dictionary( mutex_groups, assert_partial=False) if options.add_implied_preconditions: with timers.timing("Building implied facts dictionary..."): implied_facts = build_implied_facts(strips_to_sas, groups, mutex_groups) else: implied_facts = {} with timers.timing("Building mutex information", block=True): mutex_key = build_mutex_key(strips_to_sas, mutex_groups) with timers.timing("Translating task", block=True): sas_task = translate_task(strips_to_sas, ranges, translation_key, mutex_dict, mutex_ranges, mutex_key, task.init, goal_list, actions, axioms, task.use_min_cost_metric, implied_facts) print("%d effect conditions simplified" % simplified_effect_condition_counter) print("%d implied preconditions added" % added_implied_precondition_counter) if options.filter_unreachable_facts: with timers.timing("Detecting unreachable propositions", block=True): try: simplify.filter_unreachable_propositions(sas_task) except simplify.Impossible: return unsolvable_sas_task( "Simplified to trivially false goal") except simplify.TriviallySolvable: return solvable_sas_task("Simplified to empty goal") reachable_inessentials = [] for i, values in enumerate(sas_task.variables.value_names): if len(values) > 2: continue pos, neg = values for mutex in inessentials: if (pos == str(mutex)): reachable_inessentials.append(mutex) if options.mark_inessential: sas_task.variables.axiom_layers[i] = -2 print("Translator essentials: {}".format( len(sas_task.variables.ranges) - len(reachable_inessentials))) print("Translator inessentials: {}".format(len(reachable_inessentials))) return sas_task
def pddl_to_sas(task): with timers.timing("Instantiating", block=True): (relaxed_reachable, atoms, actions, axioms, reachable_action_params) = instantiate.explore(task) # Transform logical terms of all cost functions into arithmetic terms. for a in actions: if isinstance(a.cost, pddl_parser.CostNode): a.cost.transform_logic() # writing value tuples to atoms predicate_dict = dict((p.name, p ) for p in task.predicates) for a in atoms: p = predicate_dict.get(a.predicate) if p and len(p.value_mapping) > 0: a.value = p.value_mapping.get(a.args) if not relaxed_reachable: return unsolvable_sas_task("No relaxed solution") # HACK! Goals should be treated differently. if isinstance(task.goal, pddl.Conjunction): goal_list = task.goal.parts else: goal_list = [task.goal] for item in goal_list: assert isinstance(item, pddl.Literal) with timers.timing("Computing fact groups", block=True): groups, mutex_groups, translation_key, atom_groups = fact_groups.compute_groups( task, atoms, reachable_action_params) with timers.timing("Building STRIPS to SAS dictionary"): ranges, strips_to_sas = strips_to_sas_dictionary( groups, assert_partial=options.use_partial_encoding) with timers.timing("Building dictionary for full mutex groups"): mutex_ranges, mutex_dict = strips_to_sas_dictionary( mutex_groups, assert_partial=False) if options.add_implied_preconditions: with timers.timing("Building implied facts dictionary..."): implied_facts = build_implied_facts(strips_to_sas, groups, mutex_groups) else: implied_facts = {} with timers.timing("Building mutex information", block=True): mutex_key = build_mutex_key(strips_to_sas, mutex_groups) if options.exp: actions = pddl_parser.transform_exp_actions(actions, mutex_groups) compiler = EVMDDActionCompiler() actions = compiler.evmdd_action_compilation(actions) pddl_writer = SdacPDDLWriter(compiler._fact_name_dict) pddl_writer.write_pddl_files(options.domain, options.task, actions) print("done!") exit(0) task.inst_actions = actions with timers.timing("Translating task", block=True): sas_task = translate_task( strips_to_sas, ranges, translation_key, mutex_dict, mutex_ranges, mutex_key, task.init, goal_list, actions, axioms, task.use_min_cost_metric, implied_facts, atom_groups) print("%d effect conditions simplified" % simplified_effect_condition_counter) print("%d implied preconditions added" % added_implied_precondition_counter) if options.filter_unreachable_facts: with timers.timing("Detecting unreachable propositions", block=True): try: simplify.filter_unreachable_propositions(sas_task) except simplify.Impossible: return unsolvable_sas_task("Simplified to trivially false goal") except simplify.TriviallySolvable: return solvable_sas_task("Simplified to empty goal") atom_dict = dict((str(a), a) for a in atoms) new_atom_groups = [] for i in range(0, len(sas_task.variables.atom_groups)): group_str = [str(fact) for fact in sas_task.variables.atom_groups[i]] for j in range(0, len(sas_task.variables.value_names)): if group_str == sas_task.variables.value_names[j]: new_atom_groups.append(sas_task.variables.atom_groups[i]) break sas_task.variables.atom_groups = new_atom_groups for i in range(0, len(sas_task.variables.atom_groups)): group_str = [str(fact) for fact in sas_task.variables.atom_groups[i]] assert(group_str == sas_task.variables.value_names[i]) # Transform atoms of all cost functions into sas notation. # Simplify cost function for op in sas_task.operators: if isinstance(op.cost, pddl_parser.CostNode): op.cost.to_sas(sas_task.variables.atom_groups, atom_dict, sas_task.variables.deleted_true_variables) op.cost = op.cost.get_simplified_function() return sas_task
def pddl_to_sas(task, agent_id, agent_url): comm = None if agent_id >= 0 and len(agent_url) > 1: comm = AgentComm(agent_id, agent_url) with timers.timing("Instantiating", block=True): (relaxed_reachable, atoms, actions, axioms, reachable_action_params) = instantiate.explore(task, comm) if not relaxed_reachable: return unsolvable_sas_task("No relaxed solution") # HACK! Goals should be treated differently. if isinstance(task.goal, pddl.Conjunction): goal_list = task.goal.parts else: goal_list = [task.goal] for item in goal_list: assert isinstance(item, pddl.Literal) with timers.timing("Computing fact groups", block=True): groups, mutex_groups, translation_key = fact_groups.compute_groups( task, atoms, reachable_action_params, partial_encoding=USE_PARTIAL_ENCODING, comm=comm) with timers.timing("Building STRIPS to SAS dictionary"): ranges, strips_to_sas = strips_to_sas_dictionary( groups, assert_partial=USE_PARTIAL_ENCODING) if comm is not None: # Each group contains either all public or all private values private_vars = [x[0].is_private for x in groups] else: private_vars = [None for _ in groups] with timers.timing("Building dictionary for full mutex groups"): mutex_ranges, mutex_dict = strips_to_sas_dictionary( mutex_groups, assert_partial=False) if ADD_IMPLIED_PRECONDITIONS: with timers.timing("Building implied facts dictionary..."): implied_facts = build_implied_facts(strips_to_sas, groups, mutex_groups) else: implied_facts = {} with timers.timing("Building mutex information", block=True): mutex_key = build_mutex_key(strips_to_sas, mutex_groups) with timers.timing("Translating task", block=True): sas_task = translate_task(strips_to_sas, ranges, translation_key, private_vars, mutex_dict, mutex_ranges, mutex_key, task.init, goal_list, actions, axioms, task.use_min_cost_metric, implied_facts, task.agents, comm) print("%d effect conditions simplified" % simplified_effect_condition_counter) print("%d implied preconditions added" % added_implied_precondition_counter) if comm is not None: comm.close() if DETECT_UNREACHABLE and comm is None: with timers.timing("Detecting unreachable propositions", block=True): try: simplify.filter_unreachable_propositions(sas_task) except simplify.Impossible: return unsolvable_sas_task( "Simplified to trivially false goal") return sas_task