Python PDDL框架中旅行商问题递归深度错误及动作效果的正确定义

# tsp_basic.py (错误示例)

class TSPBasic:
    # ... (省略其他初始化代码)

    def create_actions(self):
        move = Action(
            "move",
            parameters=[self.start, self.finish],
            precondition=self.at(self.start) &
                         self.connected(self.start, self.finish) &
                         ~self.visited(self.finish),
            effect="&".join([  # 错误：使用字符串拼接
                str(self.at(self.finish)),
                str(self.visited(self.finish)),
                "~" + str(self.at(self.start))
            ])
        )
        return [move]

    def create_problem(self):
        # ... (省略其他代码)
        goal_conditions = [self.visited(city) for city in self.cities if city.name != self.start_city]
        goal_conditions.append(self.at(variables(self.start_city, types=["position"])[0]))
        goal = "&".join(goal_conditions) # 错误：使用字符串拼接
        # ... (省略其他代码)

# tsp_basic.py (正确示例)

from pddl.logic import Predicate, variables, And, Not # 导入And和Not

class TSPBasic:
    def __init__(self, connections, start_city):
        self.connections = connections
        self.start_city = start_city

        unique_cities = set()
        for start, end in connections:
            unique_cities.update([start, end])
        # 将城市名称转换为PDDL变量对象，并将其类型设置为"position"
        self.cities = [variables(city_name, types=["position"])[0] for city_name in unique_cities]

        self.start_var = variables("start_var", types=["position"])[0] # 定义用于动作参数的变量
        self.finish_var = variables("finish_var", types=["position"])[0] # 定义用于动作参数的变量

        # Predicates
        self.at = Predicate("at", self.start_var) # 谓词定义应使用变量
        self.connected = Predicate("connected", self.start_var, self.finish_var)
        self.visited = Predicate("visited", self.finish_var)

        self.domain = self.create_domain()
        self.problem = self.create_problem()

    def create_actions(self):
        # 注意：Action的parameters应使用未绑定的变量
        move = Action(
            "move",
            parameters=[self.start_var, self.finish_var], # 使用未绑定的变量
            precondition=self.at(self.start_var) &
                         self.connected(self.start_var, self.finish_var) &
                         ~self.visited(self.finish_var),
            effect=self.at(self.finish_var) & # 正确：直接使用逻辑运算符
                   self.visited(self.finish_var) &
                   ~self.at(self.start_var)
        )
        return [move]

    def create_problem(self):
        requirements = [Requirements.STRIPS, Requirements.TYPING]

        # 定义objects，应为具体的常量对象，而不是变量
        # 这里需要将字符串城市名转换为PDDL常量对象
        pddl_city_objects = [variables(city.name, types=["position"])[0] for city in self.cities]

        # 初始状态
        # 将start_city转换为PDDL常量对象
        start_city_obj = variables(self.start_city, types=["position"])[0]
        init = [self.at(start_city_obj)]
        for start, finish in self.connections:
            init.append(self.connected(variables(start, types=["position"])[0],
                                       variables(finish, types=["position"])[0]))

        # 目标状态：所有城市必须被访问，并返回到起始城市
        goal_conditions = [self.visited(city) for city in pddl_city_objects if city.name != self.start_city]
        goal_conditions.append(self.at(start_city_obj))
        goal = And(*goal_conditions) # 正确：使用And函数组合逻辑表达式

        problem = Problem(
            "tsp_basic_problem",
            domain=self.domain,
            requirements=requirements,
            objects=pddl_city_objects, # 确保这里传递的是常量对象
            init=init,
            goal=goal
        )
        return problem

    # ... (get_domain 和 get_problem 方法不变)