使用Python PDDL框架构建旅行商问题：Effect表达式的正确姿势

# 错误的Effect表达式构建方式
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))
    ])
)

# 正确的Effect表达式构建方式
move = Action(
    "move",
    parameters=[self.start, self.finish],
    precondition=self.at(self.start) &
                 self.connected(self.start, self.finish) &
                 ~self.visited(self.finish),
    effect=self.at(self.finish) & self.visited(self.finish) & ~self.at(self.start)
)

(and (at ?finish) (visited ?finish) (not (at ?start)))

# travelling salesman domain and problem basic case

from pddl.logic import Predicate, variables, And
from pddl.core import Domain, Problem
from pddl.action import Action
from pddl.formatter import domain_to_string, problem_to_string
from pddl.requirements import Requirements


class TSPBasic:
    def __init__(self, connections, start_city):
        self.connections = connections  # List of tuples representing connections between cities
        self.start_city = start_city  # Starting city from the TSP

        # Extracting unique cities from connections
        unique_cities = set()
        for start, end in connections:
            unique_cities.update([start, end])

        # 将城市名称转换为PDDL变量，并指定类型
        # 注意：variables函数返回一个列表，即使只有一个变量
        # 这里需要确保每个城市都作为一个PDDL常量或变量被正确定义
        # 为了简化，我们假设这些城市是问题中的对象，而不是动作参数中的变量
        # 因此，这里应该创建PDDL常量，而不是通用的变量
        self.city_objects = {city_name: variables(city_name, types=["position"])[0] for city_name in unique_cities}

        # Single city variables for actions (for parameters)
        self.start_param = variables("start", types=["position"])[0]  # Extract single city variable
        self.finish_param = variables("finish", types=["position"])[0]  # Extract single city variable

        # Predicates
        self.at = Predicate("at", self.start_param)
        self.connected = Predicate("connected", self.start_param, self.finish_param)
        self.visited = Predicate("visited", self.finish_param)

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

    def create_actions(self):
        move = Action(
            "move",
            parameters=[self.start_param, self.finish_param], # 使用动作参数变量
            precondition=self.at(self.start_param) &
                         self.connected(self.start_param, self.finish_param) &
                         ~self.visited(self.finish_param),
            # 修正：直接使用逻辑运算符组合谓词对象
            effect=self.at(self.finish_param) & self.visited(self.finish_param) & ~self.at(self.start_param)
        )
        return [move]

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

        domain = Domain(
            "tsp_basic_domain",
            requirements=requirements,
            types={"position": None},
            # 在领域中声明所有可能的城市作为常量，或者在问题中作为对象
            # 这里我们选择在问题中作为对象，所以domain constants为空
            constants=[], 
            predicates=[self.at, self.connected, self.visited],
            actions=self.create_actions()
        )

        return domain

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

        # Define objects based on unique cities
        # 修正：直接使用 city_objects 中的 PDDL 变量作为问题对象
        objects = list(self.city_objects.values())

        # Initial state
        # 修正：使用 city_objects 中的 PDDL 变量来构建初始状态
        init = [self.at(self.city_objects[self.start_city])]
        for start, finish in self.connections:
            init.append(self.connected(self.city_objects[start],
                                       self.city_objects[finish]))

        # Goal state: all cities must be visited and return to start
        # 修正：使用And操作符组合所有目标条件
        goal_conditions = [self.visited(city_obj) 
                           for city_name, city_obj in self.city_objects.items() 
                           if city_name != self.start_city]
        goal_conditions.append(self.at(self.city_objects[self.start_city]))
        goal = And(*goal_conditions) # 正确：使用And对象组合

        problem = Problem(
            "tsp_basic_problem",
            domain=self.domain,
            requirements=requirements,
            objects=objects,
            init=init,
            goal=goal
        )

        return problem

    def get_domain(self):
        return domain_to_string(self.domain)

    def get_problem(self):
        return problem_to_string(self.problem)