def parse_task(task_pddl): iterator = iter(task_pddl) assert iterator.next() == "define" problem_line = iterator.next() assert problem_line[0] == "problem" and len(problem_line) == 2 yield problem_line[1] domain_line = iterator.next() assert domain_line[0] == ":domain" and len(domain_line) == 2 yield domain_line[1] objects_opt = iterator.next() if objects_opt[0] == ":objects": yield pddl_types.parse_typed_list(objects_opt[1:]) init = iterator.next() else: yield [] init = objects_opt assert init[0] == ":init" initial = [] for fact in init[1:]: if fact[0] == "=": if conditions.is_function_comparison(fact): # numeric function initial.append(f_expression.parse_assignment(fact)) else: # object function function = conditions.parse_term(fact[1]) terms = function.args terms.append(conditions.parse_term(fact[2])) atomname = conditions.function_predicate_name(function.name) initial.append(conditions.Atom(atomname, terms)) else: initial.append( conditions.Atom( fact[0], [conditions.parse_term(term) for term in fact[1:]])) yield initial goal = iterator.next() assert goal[0] == ":goal" and len(goal) == 2 yield conditions.parse_condition(goal[1]) metric_defined = False for entry in iterator: if entry[0] == ":metric": metric_defined = True # if entry[2][0] in ["total-time", "total-cost"] : metric = (entry[1], entry[2]) yield metric if not metric_defined: metric = () yield metric
def instantiate(self, var_mapping, init_facts, fluent_facts, fluent_functions, init_function_vals, task, new_constant_axioms): # The comments for Action.instantiate apply accordingly. arg_list = [ var_mapping[conditions.Variable(par.name)].name for par in self.parameters ] name = "(%s %s)" % (self.name, " ".join(arg_list)) condition = [] try: self.condition.instantiate(var_mapping, init_facts, fluent_facts, init_function_vals, fluent_functions, task, new_constant_axioms, condition) except conditions.Impossible: return None effect_args = [ var_mapping.get(conditions.Variable(arg.name), conditions.Variable(arg.name)) for arg in self.parameters ] effect = conditions.Atom(self.name, effect_args) return PropositionalAxiom(name, condition, effect)
def parse_task(task_pddl): iterator = iter(task_pddl) assert iterator.next() == "define" problem_line = iterator.next() assert problem_line[0] == "problem" and len(problem_line) == 2 yield problem_line[1] domain_line = iterator.next() assert domain_line[0] == ":domain" and len(domain_line) == 2 yield domain_line[1] objects_opt = iterator.next() if objects_opt[0] == ":objects": yield pddl_types.parse_typed_list(objects_opt[1:]) init = iterator.next() else: yield [] init = objects_opt assert init[0] == ":init" initial = [] for fact in init[1:]: if fact[0] == "=": try: initial.append(f_expression.parse_assignment(fact)) except ValueError, e: raise SystemExit("Error in initial state specification\n" + "Reason: %s." % e) else: initial.append(conditions.Atom(fact[0], fact[1:]))
def parse(domain_pddl, task_pddl): domain_name, requirements, types, constants, predicates, functions, actions, axioms \ = parse_domain(domain_pddl) task_name, task_domain_name, objects, init, goal, use_metric = parse_task(task_pddl) assert domain_name == task_domain_name objects = constants + objects init += [conditions.Atom("=", (obj.name, obj.name)) for obj in objects] return Task(domain_name, task_name, requirements, types, objects, predicates, functions, init, goal, actions, axioms, use_metric)
def parse(domain_pddl, task_pddl): domain_name, requirements, constants, predicates, types, functions, actions, durative_actions, axioms \ = parse_domain(domain_pddl) task_name, task_domain_name, objects, init, goal, metric = parse_task(task_pddl) assert domain_name == task_domain_name objects = constants + objects init += [conditions.Atom("=", (conditions.parse_term(obj.name), conditions.parse_term(obj.name))) for obj in objects] return Task(domain_name, task_name, requirements, types, objects, predicates, init, goal, metric, actions, durative_actions, axioms, Task.FUNCTION_SYMBOLS)
def parse(domain_pddl, task_pddl): domain_name, requirements, oplinit, constants, predicates, types, functions, actions, durative_actions, axioms, modules, subplan_generators \ = parse_domain(domain_pddl) task_name, task_domain_name, module_inits, module_exits, objects, init, goal = parse_task( task_pddl) assert domain_name == task_domain_name objects = constants + objects init += [ conditions.Atom("=", (conditions.parse_term( obj.name), conditions.parse_term(obj.name))) for obj in objects ] return Task(domain_name, task_name, requirements, oplinit, types, objects, modules, predicates, init, goal, actions, durative_actions, axioms, Task.FUNCTION_SYMBOLS, subplan_generators, module_inits, module_exits)
def parse_task(task_pddl): iterator = iter(task_pddl) assert iterator.next() == "define" problem_line = iterator.next() assert problem_line[0] == "problem" and len(problem_line) == 2 yield problem_line[1] domain_line = iterator.next() assert domain_line[0] == ":domain" and len(domain_line) == 2 yield domain_line[1] objects_opt = iterator.next() if objects_opt[0] == ":objects": yield pddl_types.parse_typed_list(objects_opt[1:]) init = iterator.next() else: yield [] init = objects_opt assert init[0] == ":init" initial = [] for fact in init[1:]: if fact[0] == "=": initial.append(f_expression.parse_assignment(fact)) else: initial.append(conditions.Atom(fact[0], fact[1:])) yield initial goal = iterator.next() assert goal[0] == ":goal" and len(goal) == 2 yield conditions.parse_condition(goal[1]) use_metric = False for entry in iterator: if entry[0] == ":metric": if entry[1]=="minimize" and entry[2][0] == "total-cost": use_metric = True else: assert False, "Unknown metric." yield use_metric for entry in iterator: assert False, entry
def instantiate(self, var_mapping, init_facts, fluent_facts): # The comments for Action.instantiate apply accordingly. arg_list = [self.name] + [ var_mapping[par.name] for par in self.parameters[:self.num_external_parameters] ] name = "(%s)" % " ".join(arg_list) condition = [] try: self.condition.instantiate(var_mapping, init_facts, fluent_facts, condition) except conditions.Impossible: return None effect_args = [ var_mapping.get(arg.name, arg.name) for arg in self.parameters[:self.num_external_parameters] ] effect = conditions.Atom(self.name, effect_args) return PropositionalAxiom(name, condition, effect)
def parse(domain_pddl, task_pddl): domain_name, domain_requirements, types, constants, predicates, functions, actions, axioms \ = parse_domain(domain_pddl) task_name, task_domain_name, task_requirements, objects, init, goal, use_metric = parse_task( task_pddl) assert domain_name == task_domain_name requirements = Requirements( sorted( set(domain_requirements.requirements + task_requirements.requirements))) objects = constants + objects check_for_duplicates( [o.name for o in objects], errmsg="error: duplicate object %r", finalmsg="please check :constants and :objects definitions") init += [conditions.Atom("=", (obj.name, obj.name)) for obj in objects] return Task(domain_name, task_name, requirements, types, objects, predicates, functions, init, goal, actions, axioms, use_metric)
def normalize(self, time, results): used_variables = list(self.head.free_variables() | self.value.free_variables()) typed1, conjunction_parts1, term1 = self.head.compile_objectfunctions_aux( used_variables) typed2, conjunction_parts2, term2 = self.value.compile_objectfunctions_aux( used_variables) assert isinstance(term1, conditions.Variable) add_params = set( [typed for typed in typed1 if not typed.name == term1.name] + typed2) del_params = set(typed1 + typed2) add_conjunction_parts = conjunction_parts1[1:] + conjunction_parts2 del_conjunction_parts = conjunction_parts1 + conjunction_parts2 del_conjunction_parts = conjunction_parts1[1:] + conjunction_parts2 # conjunctive_parts1[0] is left out because we do not need the condition # that the atom in the del effect hast been true before # These conjunction parts are sufficient under the add-after-delete semantics. # Under the consistent effect semantics we need a further condition # that prevents deleting the added predicate. del_param = conjunction_parts1[0].args[-1] del_conjunction_parts.append( conditions.NegatedAtom("=", [del_param, term2])) del_effect = ConjunctiveEffect([ conjunction_parts1[0].negate(), ]) atom_name = conjunction_parts1[0].predicate atom_parts = list(conjunction_parts1[0].args) atom_parts[-1] = term2 add_effect = ConjunctiveEffect([ conditions.Atom(atom_name, atom_parts), ], time) add_conjunction = conditions.Conjunction(add_conjunction_parts) del_conjunction = conditions.Conjunction(del_conjunction_parts) if time == "start": del_condition = [ del_conjunction, conditions.Truth(), conditions.Truth() ] add_condition = [ add_conjunction, conditions.Truth(), conditions.Truth() ] elif time == "end": add_condition = [ conditions.Truth(), conditions.Truth(), add_conjunction ] del_condition = [ conditions.Truth(), conditions.Truth(), del_conjunction ] else: add_condition = add_conjunction del_condition = del_conjunction if len(add_conjunction_parts) > 0: add_effect = ConditionalEffect(add_condition, add_effect, time) del_effect = ConditionalEffect(del_condition, del_effect) if len(add_params) > 0: add_effect = UniversalEffect(add_params, add_effect, time) del_effect = UniversalEffect(del_params, del_effect, time) results.append(add_effect) results.append(del_effect) # value "undefined" must be treated specially because it has not the type # required in del_params if term2.name != "undefined": del_undef_params = set([ typed for typed in del_params if not typed.name == del_param.name ]) atom_parts = list(conjunction_parts1[0].args) atom_parts[-1] = conditions.ObjectTerm("undefined") del_undef_effect = ConjunctiveEffect([ conditions.NegatedAtom(atom_name, atom_parts), ], time) del_undef_conjunction_parts = del_conjunction_parts[:-1] del_undef_conjunction = conditions.Conjunction( del_undef_conjunction_parts) if time == "start": del_undef_condition = [ del_undef_conjunction, conditions.Truth(), conditions.Truth() ] elif time == "end": del_undef_condition = [ conditions.Truth(), conditions.Truth(), del_undef_conjunction ] else: del_undef_condition = del_undef_conjunction if len(del_undef_conjunction_parts) > 0: del_undef_effect = ConditionalEffect(del_undef_condition, del_undef_effect, time) if len(del_undef_params) > 0: del_undef_effect = UniversalEffect(del_undef_params, del_undef_effect, time) results.append(del_undef_effect)
def to_untyped_strips(self): return conditions.Atom(self.type, [self.name])
def parse_task(task_pddl): iterator = iter(task_pddl) assert iterator.next() == "define" problem_line = iterator.next() assert problem_line[0] == "problem" and len(problem_line) == 2 yield problem_line[1] domain_line = iterator.next() assert domain_line[0] == ":domain" and len(domain_line) == 2 yield domain_line[1] module_opt = iterator.next() if module_opt[0] == ":moduleoptions": yield [modules.ModuleInit.parse(mi) for mi in module_opt[1:]] module_exit_opt = iterator.next() else: yield [] module_exit_opt = module_opt if module_exit_opt[0] == ":moduleexitoptions": yield [modules.ModuleExit.parse(mi) for mi in module_exit_opt[1:]] objects_opt = iterator.next() else: yield [] objects_opt = module_exit_opt if objects_opt[0] == ":objects": yield pddl_types.parse_typed_list(objects_opt[1:]) init = iterator.next() else: yield [] init = objects_opt assert init[0] == ":init" initial = [] for fact in init[1:]: if fact[0] == "=": if conditions.is_function_comparison(fact): # numeric function initial.append(f_expression.parse_assignment(fact)) else: # object function function = conditions.parse_term(fact[1]) terms = function.args terms.append(conditions.parse_term(fact[2])) atomname = conditions.function_predicate_name(function.name) initial.append(conditions.Atom(atomname, terms)) else: initial.append( conditions.Atom( fact[0], [conditions.parse_term(term) for term in fact[1:]])) yield initial goal = iterator.next() assert goal[0] == ":goal" and len(goal) == 2 yield conditions.parse_condition(goal[1]) for entry in iterator: if entry[0] == ":metric" and entry[1] == "minimize": if entry[2][0] in ["total-time", "total-cost"]: continue assert False, "Can only minimize total-time or total-cost, got: " + str( entry)
def parse_task(task_pddl): iterator = iter(task_pddl) define_tag = next(iterator) assert define_tag == "define" problem_line = next(iterator) assert problem_line[0] == "problem" and len(problem_line) == 2 yield problem_line[1] domain_line = next(iterator) assert domain_line[0] == ":domain" and len(domain_line) == 2 yield domain_line[1] requirements_opt = next(iterator) if requirements_opt[0] == ":requirements": requirements = requirements_opt[1:] objects_opt = next(iterator) else: requirements = [] objects_opt = requirements_opt yield Requirements(requirements) if objects_opt[0] == ":objects": yield pddl_types.parse_typed_list(objects_opt[1:]) init = next(iterator) else: yield [] init = objects_opt assert init[0] == ":init" initial = [] initial_true = set() initial_false = set() initial_assignments = dict() for fact in init[1:]: if fact[0] == "=": try: assignment = f_expression.parse_assignment(fact) except ValueError as e: raise SystemExit("Error in initial state specification\n" + "Reason: %s." % e) if not isinstance(assignment.expression, f_expression.NumericConstant): raise SystemExit("Illegal assignment in initial state " + "specification:\n%s" % assignment) if assignment.fluent in initial_assignments: prev = initial_assignments[assignment.fluent] if assignment.expression == prev.expression: print("Warning: %s is specified twice" % assignment, "in initial state specification") else: raise SystemExit("Error in initial state specification\n" + "Reason: conflicting assignment for " + "%s." % assignment.fluent) else: initial_assignments[assignment.fluent] = assignment initial.append(assignment) elif fact[0] == "not": atom = conditions.Atom(fact[1][0], fact[1][1:]) check_atom_consistency(atom, initial_false, initial_true, False) initial_false.add(atom) else: atom = conditions.Atom(fact[0], fact[1:]) check_atom_consistency(atom, initial_true, initial_false) initial_true.add(atom) initial.extend(initial_true) yield initial goal = next(iterator) assert goal[0] == ":goal" and len(goal) == 2 yield conditions.parse_condition(goal[1]) use_metric = False for entry in iterator: if entry[0] == ":metric": if entry[1] == "minimize" and entry[2][0] == "total-cost": use_metric = True else: assert False, "Unknown metric." yield use_metric for entry in iterator: assert False, entry