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