def compile_to_exogenous_axioms(evaluations, domain, streams): # TODO: no attribute certified import pddl fluent_predicates = get_fluents(domain) certified_predicates = { get_prefix(a) for s in streams for a in s.certified } future_map = {p: 'f-{}'.format(p) for p in certified_predicates} augment_evaluations(evaluations, future_map) rename_future = lambda a: rename_atom(a, future_map) derived_map = {p: 'd-{}'.format(p) for p in certified_predicates} rename_derived = lambda a: rename_atom(a, derived_map) for action in domain.actions: action.precondition = replace_predicates(derived_map, action.precondition) for effect in action.effects: assert (isinstance(effect, pddl.Effect)) effect.condition = replace_predicates(derived_map, effect.condition) for axiom in domain.axioms: axiom.condition = replace_predicates(derived_map, axiom.condition) #fluent_predicates.update(certified_predicates) for stream in list(streams): if not isinstance(stream, Stream): raise NotImplementedError(stream) streams.append( create_static_stream(stream, evaluations, fluent_predicates, rename_future)) stream_atom = streams[-1].certified[0] domain.predicate_dict[get_prefix(stream_atom)] = pddl.Predicate( get_prefix(stream_atom), get_args(stream_atom)) preconditions = [stream_atom] + list(map(rename_derived, stream.domain)) for fact in stream.certified: derived_fact = fd_from_fact(rename_derived(fact)) external_params = derived_fact.args internal_params = tuple(p for p in (stream.inputs + stream.outputs) if p not in derived_fact.args) parameters = tuple( pddl.TypedObject(p, OBJECT) for p in (external_params + internal_params)) #precondition = pddl.Conjunction(tuple(map(fd_from_fact, [stream_atom] + # list(map(rename_derived, stream.domain))))) #precondition = pddl.Disjunction([fd_from_fact(fact), precondition]) # TODO: quantifier domain.axioms.extend([ pddl.Axiom(name=derived_fact.predicate, parameters=parameters, num_external_parameters=len(external_params), condition=make_preconditions(preconditions)), pddl.Axiom(name=derived_fact.predicate, parameters=parameters[:len(external_params)], num_external_parameters=len(external_params), condition=fd_from_fact(fact)), ]) stream.certified = tuple( set(stream.certified) | set(map(rename_future, stream.certified)))
def parse_axiom(alist, type_dict, predicate_dict): assert len(alist) == 3 assert alist[0] == ":derived" predicate = parse_predicate(alist[1]) condition = parse_condition(alist[2], type_dict, predicate_dict) return pddl.Axiom(predicate.name, predicate.arguments, len(predicate.arguments), condition)
def make_axiom(parameters, preconditions, derived): predicate = get_prefix(derived) external_parameters = list(get_args(derived)) internal_parameters = [p for p in parameters if p not in external_parameters] parameters = external_parameters + internal_parameters return pddl.Axiom(name=predicate, parameters=make_parameters(parameters), num_external_parameters=len(external_parameters), condition=make_preconditions(preconditions))
def parse_global_constraint( alist, type_dict, predicate_dict): # global constraints are parsed as special Axioms if DEBUG: print("parsing constraint %s" % [alist]) iterator = iter(alist) action_tag = next(iterator) assert action_tag == ":constraint", "Expected ':constraint' got '%s'" % action_tag name = next(iterator) parameters_tag_opt = next(iterator) if parameters_tag_opt == ":parameters": parameters = parse_typed_list(next(iterator), only_variables=True) condition_tag = next(iterator) else: parameters = [] condition_tag = parameters_tag_opt assert condition_tag == ":condition", "Expected ':condition' got '%s'" % action_tag condition_list = next(iterator) assert condition_list, "Empty conditions are not allowed for global constraints" condition = parse_condition(condition_list, type_dict, predicate_dict) condition = condition.simplified() for rest in iterator: assert False, rest return pddl.Axiom(name, parameters, len(parameters), condition, True)
def disable(self, evaluations, domain): #assert not self.disabled super(StreamInstance, self).disable(evaluations, domain) if not self.external.is_fluent(): # self.fluent_facts: if self.external.is_negated() and not self.successes: evaluations[evaluation_from_fact(self.get_blocked_fact())] = INTERNAL return if self.axiom_predicate is not None: return index = len(self.external.disabled_instances) self.external.disabled_instances.append(self) self.axiom_predicate = '_ax{}-{}'.format(self.external.blocked_predicate, index) evaluations[evaluation_from_fact(self.get_blocked_fact())] = INTERNAL # TODO: allow reporting back which components lead to failure import pddl static_fact = (self.axiom_predicate,) + self.external.inputs preconditions = [static_fact] + list(self.fluent_facts) self.disabled_axiom = pddl.Axiom(name=self.external.blocked_predicate, parameters=make_parameters(self.external.inputs), num_external_parameters=len(self.external.inputs), condition=make_preconditions(preconditions)) domain.axioms.append(self.disabled_axiom)
def convert_axiom(axiom): import pddl parameters = convert_parameters(axiom.parameters) return pddl.Axiom(axiom.name, parameters, len(parameters), convert_condition(axiom.condition).simplified())