def _push_with_children_to_stack(self, expression: FNode, **kwargs):
"""Add children to the stack."""
if expression.is_forall() or expression.is_exists():
self.stack.append((True, expression))
else:
super(walkers.Simplifier,
self)._push_with_children_to_stack(expression, **kwargs)
def _get_ground_fluent(self, fluent: FNode,
assignments: Dict[Expression, Expression]) -> FNode:
assert fluent.is_fluent_exp()
new_args = []
for p in fluent.args:
new_args.append(self._subs_simplify(p, assignments))
return self.manager.FluentExp(fluent.fluent(), tuple(new_args))
def walk_variable_exp(self, expression: model.FNode,
args: List[proto.Expression]) -> proto.Expression:
return proto.Expression(
atom=proto.Atom(symbol=expression.variable().name),
list=[],
kind=proto.ExpressionKind.Value("VARIABLE"),
type=str(expression.variable().type),
)
def walk_param_exp(self, expression: model.FNode,
args: List[proto.Expression]) -> proto.Expression:
return proto.Expression(
atom=proto.Atom(symbol=expression.parameter().name),
list=[],
kind=proto.ExpressionKind.Value("PARAMETER"),
type=str(expression.parameter().type),
)
def walk_object_exp(self, expression: model.FNode,
args: List[proto.Expression]) -> proto.Expression:
return proto.Expression(
atom=proto.Atom(symbol=expression.object().name),
list=[],
kind=proto.ExpressionKind.Value("CONSTANT"),
type=str(expression.object().type),
)
def walk_fluent_exp(self, expression: FNode, args: List[FNode]) -> FNode:
if expression.fluent() not in self.static_fluents:
return self.manager.FluentExp(expression.fluent(), tuple(args))
else:
assert self.problem is not None
for a in args:
if not a.is_constant():
return self.manager.FluentExp(expression.fluent(),
tuple(args))
return self.problem.initial_value(
self.manager.FluentExp(expression.fluent(), tuple(args)))
def walk_fluent_exp(
self, expression: FNode,
args: List['unified_planning.model.types.Type']
) -> Optional['unified_planning.model.types.Type']:
assert expression.is_fluent_exp()
f = expression.fluent()
if len(args) != len(f.signature):
return None
for (arg, param) in zip(args, f.signature):
if not self.is_compatible_type(arg, param.type):
return None
return f.type
def walk_fluent_exp(self, expression: model.FNode,
args: List[proto.Expression]) -> proto.Expression:
sub_list = []
sub_list.append(
proto.Expression(
atom=proto.Atom(symbol=expression.fluent().name),
kind=proto.ExpressionKind.Value("FLUENT_SYMBOL"),
type=str(expression.fluent().type),
))
sub_list.extend(args)
return proto.Expression(
atom=None,
list=sub_list,
kind=proto.ExpressionKind.Value("STATE_VARIABLE"),
type=str(expression.fluent().type),
)
def walk_param_exp(
self, expression: FNode,
args: List['unified_planning.model.types.Type']
) -> 'unified_planning.model.types.Type':
assert expression is not None
assert len(args) == 0
return expression.parameter().type
def walk_int_constant(self, expression: model.FNode,
args: List[proto.Expression]) -> proto.Expression:
return proto.Expression(
atom=proto.Atom(int=expression.int_constant_value()),
list=[],
kind=proto.ExpressionKind.Value("CONSTANT"),
type="integer",
)
def walk_bool_constant(self, expression: model.FNode,
args: List[proto.Expression]) -> proto.Expression:
return proto.Expression(
atom=proto.Atom(boolean=expression.bool_constant_value()),
list=[],
kind=proto.ExpressionKind.Value("CONSTANT"),
type="bool",
)
def walk_forall(self, expression: FNode, args: List[FNode]) -> FNode:
assert len(args) == 1
free_vars: Set[
'unified_planning.model.Variable'] = self.env.free_vars_oracle.get_free_variables(
args[0])
vars = tuple(var for var in expression.variables() if var in free_vars)
if len(vars) == 0:
return args[0]
return self.manager.Forall(args[0], *vars)
def walk_real_constant(self, expression: model.FNode,
args: List[proto.Expression]) -> proto.Expression:
return proto.Expression(
atom=proto.Atom(real=self._protobuf_writer.convert(
expression.real_constant_value())),
list=[],
kind=proto.ExpressionKind.Value("CONSTANT"),
type="real",
)
def walk_param_exp(self, expression: FNode, args: List[FNode]) -> FNode:
assert self._assignments is not None
res = self._assignments.get(expression.parameter(), None)
if res is not None:
res, = self.manager.auto_promote(res)
assert type(res) is FNode
return res
else:
raise UPProblemDefinitionError(
f"Value of Parameter {str(expression)} not found in {str(self._assignments)}"
)
def walk_fluent_exp(self, expression: FNode, args: List[FNode]) -> FNode:
new_exp = self.manager.FluentExp(expression.fluent(), tuple(args))
assert self._assignments is not None
res = self._assignments.get(new_exp, None)
if res is not None:
res, = self.manager.auto_promote(res)
assert type(res) is FNode
return res
else:
raise UPProblemDefinitionError(
f"Value of Fluent {str(expression)} not found in {str(self._assignments)}"
)
def _compute_node_result(self, expression: FNode, **kwargs):
"""Apply function to the node and memoize the result.
Note: This function assumes that the results for the children
are already available.
"""
key = self._get_key(expression, **kwargs)
if key not in self.memoization:
try:
f = self.functions[expression.node_type]
except KeyError:
f = self.walk_error
if not (expression.is_forall() or expression.is_exists()):
args = [self.memoization[self._get_key(s, **kwargs)] \
for s in self._get_children(expression)]
self.memoization[key] = f(expression, args=args, **kwargs)
else:
self.memoization[key] = f(expression,
args=expression.args,
**kwargs)
else:
pass
def _create_new_action_with_given_precond(
self, precond: FNode,
original_action: InstantaneousAction) -> InstantaneousAction:
new_action = original_action.clone()
new_action.name = self.get_fresh_name(original_action.name)
new_action.clear_preconditions()
if precond.is_and():
for leaf in precond.args:
new_action.add_precondition(leaf)
else:
new_action.add_precondition(precond)
assert self._new_to_old is not None
self._new_to_old[new_action] = original_action
self._map_old_to_new_action(original_action, new_action)
return new_action
def walk_operator(self, expression: model.FNode,
args: List[proto.Expression]) -> proto.Expression:
sub_list = []
sub_list.append(
proto.Expression(
atom=proto.Atom(symbol=map_operator(expression.node_type)),
list=[],
kind=proto.ExpressionKind.Value("FUNCTION_SYMBOL"),
type="",
))
# forall/exists: add the declared variables from the payload to the beginning of the parameter list.
if expression.is_exists() or expression.is_forall():
sub_list.extend([
self._protobuf_writer.convert(p)
for p in expression.variables()
])
sub_list.extend(args)
return proto.Expression(
atom=None,
list=sub_list,
kind=proto.ExpressionKind.Value("FUNCTION_APPLICATION"),
type="",
)
def _help_walk_quantifiers(self, expression: FNode,
args: List[FNode]) -> List[FNode]:
vars = expression.variables()
type_list = [v.type for v in vars]
possible_objects: List[List[Object]] = [
list(self._problem.objects_hierarchy(t)) for t in type_list
]
#product of n iterables returns a generator of tuples where
# every tuple has n elements and the tuples make every possible
# combination of 1 item for each iterable. For example:
#product([1,2], [3,4], [5,6], [7]) =
# (1,3,5,7) (1,3,6,7) (1,4,5,7) (1,4,6,7) (2,3,5,7) (2,3,6,7) (2,4,5,7) (2,4,6,7)
subs_results = []
for o in product(*possible_objects):
subs: Dict[Expression, Expression] = dict(zip(vars, list(o)))
subs_results.append(self._substituter.substitute(args[0], subs))
return subs_results
def walk_exists(self, expression: FNode, args: List[FNode]) -> FNode:
assert self._problem is not None
assert len(args) == 1
if args[0].is_bool_constant():
if args[0].bool_constant_value():
return self.manager.TRUE()
return self.manager.FALSE()
vars = expression.variables()
type_list = [v.type for v in vars]
possible_objects: List[List[Object]] = [
list(self._problem.objects_hierarchy(t)) for t in type_list
]
#product of n iterables returns a generator of tuples where
# every tuple has n elements and the tuples make every possible
# combination of 1 item for each iterable. For example:
#product([1,2], [3,4], [5,6], [7]) =
# (1,3,5,7) (1,3,6,7) (1,4,5,7) (1,4,6,7) (2,3,5,7) (2,3,6,7) (2,4,5,7) (2,4,6,7)
for o in product(*possible_objects):
subs: Dict[Expression, Expression] = dict(zip(vars, list(o)))
result = self._deep_subs_simplify(args[0], subs)
assert result.is_bool_constant()
if result.bool_constant_value():
return self.manager.TRUE()
return self.manager.FALSE()
def walk_all_types(self, expression: FNode,
args: List[Set[FNode]]) -> Set[FNode]:
res = set(x for y in args for x in y)
if expression.is_fluent_exp():
res = res | {expression}
return res