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())
