Large Language Models Can Plan Your Travels Rigorously with Formal Verification Tools（2024）

大型语言模型可以使用正式验证工具严格规划您的旅行

摘要

大型语言的最新进展模型（LLM），拥有丰富的世界工具使用知识和能力
推理，培养了许多LLM规划算法。然而，LLM并没有显示出能够精确求解复杂的组合优化问题。在Xie等人（2024）中，作者提出了TravelPlanner，这是一个美国国内旅行计划基准，并展示了LLM自己无法制定旅行计划，gpt4以0.6%的最佳成功率满足用户需求。在这项工作中，我们建议使LLM能够正式将旅行计划问题表述为可满足性模理论（SMT）并求解问题，并交互使用SMT解算器自动求解组合搜索问题SMT求解器保证了输入约束的可满足性，LLM可以与我们的框架。当输入约束不能满足时，我们的基于LLM的框架将以交互方式向用户提供建议通过自动使用SMT求解器进行推理。我们评估我们与TravelPlanner的框架，并实现
成功率达97%。我们还创建了一个单独的包含国际旅行基准的数据集，并使用这两个数据集来评估我们的交互式规划框架的有效性，当不能满足初始用户查询时。我们的框架可以生成有效的计划，我们的平均成功率为78.6%，数据集和TravelPlanner的85.0%，不同的人类偏好。

1简介

最近的工作表明，大型语言模型（LLM）（Brown等人，2020；欧阳等人。，2022; Achiam et al.，2023），拥有丰富的世界知识、通过工具收集信息的能力，以及推理能力在解决规划问题方面具有显著的潜力（Huang et al。，2022a；安等人，2022；姚等，2022；歌曲等人，2023）。然而，的规划场景现有的LLM规划工作仍然有限相当简单的任务，如家庭清洁其中代理只考虑一个或几个约束。现代LLM不太适合直接解决具有多级约束的高度复杂的组合优化问题，因为它们基于令牌生成响应从他们的训练数据中得出的概率，以及没有天生的表演能力严格的逻辑或数学推理。想象一下你正在为暑假做准备长途行走你有一周的假期，3000美元的预算，并且渴望有一个美丽的地方海滩和美味的海鲜餐厅。制作清晰而详细的计划，你需要利用各种搜索航班的工具，拥有著名海洋的城市景点、海鲜餐厅、住宿，并且可能需要重复该过程以确保总价在您的预算范围内。即使对人类来说，这是一个复杂而耗时的过程完成的事业。LLM代理是否能够处理复杂而现实的规划像这样的问题？为了研究这个问题，谢等人（2024）提出美国国内旅行规划基准、TravelPlanner和显示
LLM无法处理此任务即使是最强的LLM GPT-4也只能实现0.6%的成功率，而无需访问预先收集的信息。
旅行计划问题包含多种限制条件，包括时间、预算、目的地、运输方式等，使其极其LLM代理在考虑所有约束的情况下搜索可行的计划具有挑战性。解决这个问题问题，另一种方法是通过基于约束的规划将问题形式化为约束满足问题（CSP）（Dechter，2003; Lozano-Pérez和Kaelbling，2014），布尔型可满足性问题（SAT）（Kautz和Selman，1999; Rintanen，2012），或可满足性模理论（SMT）（Barrett等人，2010；De Moura和比约纳，2011年；Dantam等人，2016）并解决它使用现有的基于算法的求解器（Dutertre和德莫拉，2006年；De Moura和Bjørner，2008年；Barrett等人，2011年）。然而，作为人类的天性语言查询没有固定的格式，基于约束的规划者需要提取关键信息从输入查询中准确地对问题进行建模。那些基于算法的规划工具通常有一个陡峭的学习曲线。至关重要的是，即使提取的关键信息是正确的，建议查询本身可能不令人满意，因此用户将需要使用多次查询工具修改的输入。
LLM擅长解析人工输入和交互，但很难严格接受所有约束考虑在内，而SMT解决方案是健全的并完全解决了多约束的可满足性问题，但无法处理动态的、通用的、有时模棱两可的自然语言要求。在这项工作中，我们提出了一个结合了这两种方法优点的框架通过使LLM能够将SMT求解器作为一种工具正式制定、解决和推理旅行计划问题。在我们的框架中LLM首先将自然语言输入翻译为固定的JSON格式。然后，通过指令步骤以及相应的使用SMT求解器的代码解决示例旅行计划问题，LLM学习模式并推广到新的输入。执行LLM生成的代码对查询进行编码需求并调用求解器，该求解器保证生成计划（如果存在）。此外，如果输入查询不满足，SMT求解器可以确定使问题无法满足的确切约束，LLM可以使用这些约束来提出通过分析修改查询的建议无法满足的原因，并与人类交互通信以修改查询，直到它变得令人满意。
我们通过不同的LLM评估我们的框架使用TravelPlanner Xie等人（2024），在其验证集中包含180个可满足的查询以及在其测试集中的1000个可满足查询。我们的框架实现了98.9%的最佳最终通过率在验证集中为97.0%。到为了进一步评估不满足查询的计划修复能力，我们修改了TravelPlanner的培训设置不令人满意，以及还构建了另一个国际旅行数据集包含39个不满足的查询，类型为与TravelPlanner不同的限制。我们在两个数据集上进行评估，并展示我们的框架交互式满足旅行的能力为具有修改其约束的不同偏好的用户制定计划。我们还通过消融研究验证了我们框架的关键组成部分的积极影响，包括能力迭代调用SMT求解器进行验证从SMT解决方案中收集不满意的原因，以及整合人类反馈以更好地与人类偏好。最后，我们通过编码来测试我们的框架的泛化能力现有指令步骤的看不见的约束例如。所有的实验都表明该框架可以可靠地处理各种人工输入，以交互方式提供正式验证的计划根据不同的人类偏好修改不满意的查询，并可以有效地进行调整到不同的LLM。

2相关工作

LLM规划。LLM在推理等各种任务中表现出了显著的智力（魏等人，2022；Kojima等人，2022；姚等，2022）和工具使用（Qin等人，2023；Schick等人，2024），提供了有前景的规划能力的潜力。以前的工作解决规划问题通过多种方式：1）将任务分解为子任务并按顺序规划子目标（魏等人，2022；姚等，2022；Shen等，2024）；2.使用树等方法生成多个计划以及图搜索和选择最优解（王等，2022；姚等，2024；
赵等人，2024；Besta等人，2024；郝等。，2023); 3） 反思经验与提炼
基于环境反馈的计划（Shinn等人，2024；Madaan等人，2024；Chen等。，2023b）；4） 将任务形式化，并与外部规划师一起协助规划（Liu et al.，2023；关等人，2023；Chen等人，2023a）。这些方法在Huang等人（2024）中进行了详细总结。虽然这些规划算法已经表明有希望的结果是，他们的规划场景仅限于具有单一目标函数的简单任务。谢等人（2024）提出了一个现实的和复杂的旅行计划基准和测试各种LLM规划算法表明LLM无法处理多常量任务。而刘等人（2023）；Guan等人（2023）利用LLM来处理信息和煽动PDDL中的问题（Aeronautiques等人，1998；Haslum等人，2019）为了考虑多个目标，他们必须用启发式搜索无法验证生成的计划。
基于算法的规划。另一种方式解决旅行计划问题是通过基于算法的规划，如启发式搜索（Helmert，2006；Hoffmann和Nebel，2001；Vidal，2014）和基于约束的方法（Kautz和Selman，1999年；Rintanen，20122014；LozanoPérez和Kaelbling，2014年；Dantam等人，2016）。
然而，启发式搜索并不能保证找到计划，以及纯粹的基于约束的计划不能概括为不同的人类自然语言输入。我们的框架支持LLM利用基于约束的规划方法翻译和形式化各种人类查询转化为SMT问题。由于SMT解算器是健全的并且完整，生成的计划保证是正确的。如果SMT求解器无法找到解决方案，则验证该问题不符合要求并且求解器可以输出不满意的原因未来使用。
LLM工具使用。工具使用对LLM至关重要因为它允许LLM利用强大的外部工具，以提高可靠性。近期作品探索LLM如何利用外部工具作为搜索引擎、操作环境，以及代码生成器（Press等人，2022；姚等人。，2022; Schick等人，2024；梁等，2023；辛格等人，2023；彭等，2023；Song等人，2023；Huang等人，2022b），以提供反馈或额外信息在我们的框架中，LLM生成将旅行计划问题公式化为的代码SMT问题，并调用SMT求解器来解决它。这克服了LLM未能考虑所有因素通过严格编码所有约束来约束并用求解器求解。

3方法

我们提出了一个框架，为LLM配备制定和解决旅行计划的工具问题作为SMT问题，如图1所示。在里面在我们的框架中，我们多次调用LLM来实现许多不同的功能：将自然语言查询转换为JSON格式描述，生成公式化问题的步骤，以及基于步骤生成代码。此外，当输入查询不可满足时，LLM对现状的原因提出建议并基于建议修改现有代码。

3.1可满足的计划解决

3.1.1问题说明

我们将旅行计划问题定义为：给定人类人格的自然语言描述旅行计划的约束条件C，系统应输出一个满足C的计划。旅行从开始城市o，前往k个目的地城市，然后返回o.旅行时间为n天。旅行需要k+1出行交通方式从k+1个城市到城市。旅游参观n个景点，在3n个餐厅用餐，以及n−1个住宿夜晚。表1总结了的约束条件C我们使用的两个数据集。输出计划应满足C并明确指定要访问的城市交通方式、景点、餐厅，以及每天的住宿。见附录A
例如输入查询和输出计划。

3.1.2 NL-JSON翻译

旅行计划问题是一个现实世界中的复杂问题包含时间、地点、预算等各种约束条件的长期规划问题。这些信息以不同的形式包含在人类的自然语言指令中。这个我们框架的第一步是提取重要的来自自然语言输入的信息，以及翻译成JSON格式的问题描述，如图1第1部分所示。提供LLM带有JSON中所需字段的描述以及三个翻译实例。参见C.1.1完整的NL-JSON翻译提示。

图1：框架概述。粉红色区域代表人类，蓝色区域代表LLM，灰色区域表示SMT解算器，绿色区域表示生成的计划。给定一个自然语言查询，LLM 1）将其转换为JSON格式，2）生成步骤将其公式化为SMT问题，3）生成相应的对问题进行编码并调用求解器的代码。如果解算器无法找到解决方案，LLM将收集信息，分析当前情况，并提供交互式修改查询的建议。LLM然后更新根据建议编写代码，并再次调用求解器以找到可行的计划。

3.1.3 JSON步骤生成

制定旅行计划问题的步骤各不相同，随着限制条件的变化，例如目的地城市的数量、旅行天数和特殊情况餐厅烹饪要求。然而，尽管步骤可能不同，它们具有相似的模式。我们为LLM提供JSON问题说明和提示中JSON步骤生成的三个示例，使其能够概括为不同的输入查询。我们将步骤分为
基于约束类型的子部分。对于例如，指定“行程跨度3天”约束，步骤如下：
1.为两个城市之间的交通设置“t_dates”变量
2.断言第一次运输发生在第一天（第0天），最后一次发生在最后一天（第2天）
而对于要求在5天内前往2个目的地城市的新查询，步骤变为：
1.为3个城市之间的交通设置“t_dates”变量
2.断言第一次运输发生在第一天（第0天），最后发生在最后一天（第4天），第二个可能发生在这两者之间的任何一天
JSON步骤提示见附录C.1.2。

3.1.4步骤代码生成

受梁等人（2023）的启发，我们直接提示生成语言模型程序的LLM Python通过提供CitySearch、FlightSearch、AttractionSearch、DistanceSearch、AccommodationSearch、RestaurantSearch API和SMT求解器，并演示如何使用这些功能中的每一个。使用生成的如何解决每个问题的步骤约束条件下，我们将这些步骤作为说明提供到LLM，如图1第3部分所示。

图2显示LLM如何推广到新的指令步骤给exmaples写相应的代码。看见
步骤代码生成提示见附录C.1.3。

3.1.5 SMT解算器

在收集了生成的代码后，我们的框架执行代码来对问题进行编码并调用SMT求解器。由于SMT解算器是健全和完整的，它保证找到一个解决方案，如果存在的话。因此，如果约束如果满足，求解器生成一个正式验证的计划。此外，当约束为不满足，求解器输出不满足原因和LLM可以基于其常识和推理能力，分析原因，积极收集更多信息，并为人类提供修改约束的建议。我们用提取不满意的原因Z3求解器的get_unse_core函数（De Moura和Bjørner，2008）。当框架证明如果约束条件不令人满意，则继续
交互式计划修复的原因。

3.2交互式计划修复

由于旅行计划问题是一个现实世界中的复杂问题，涉及到不同的约束条件
当所提出的查询不可满足时，LLM的推理能力和常识分析现状和提供的知识建议变得至关重要。此外，这些功能实现了一种互动环境，在这种环境中，人类可以同意、不同意或提供评论对LLM建议的反馈。LLM然后可以输出基于不同人类偏好的个性化计划。
受ReAct（Yao et al.，2022）的启发，在我们的框架中，LLM可以采取行动收集基于不满意原因的信息，分析基于收集信息的当前情况，或提供建议。我们为LLM配备了信息收集API及其描述用法如图1所示，不满意的原因是“运输0的无效航班”原因，LLM首先采取行动收集航班通过调用FlightCheck API获取信息。实现圣彼得堡和之间没有航班Rockford，LLM分析并决定改变目的地城市。然后，它运行FlightSearch API搜索从圣出发的所有可能的目的地。Petersburg，并最终选择其中一个是建议的目的地。LLM将此作为并等待用户的反馈。反馈可以是同意、不同意、任何
偏好的自然语言描述，甚至用户自己提出的修改。如果用户不同意该建议或提供了他们的首选项，框架开始另一次迭代并提出了新的建议。如果用户同意根据建议或提出自己的修改，框架通过输入以下内容继续与原始代码一起修改LLM并提示其修改代码。通过运行修改后的代码，框架生成如果修改的约束是可满足的，则为计划。否则，框架会收集不满意的理由并开始另一轮。

4数据集

访问我们的框架的能力1）概括对于看不见的约束和2）不满足查询的交互式计划修复，我们提出了一个数据集，不满足圣诞节，这带来了新的限制
不包括在TravelPlanner中（Xie et al.，2024）并且在该设置下包含39个不满足的查询。不饱和圣诞节中的查询旨在创建年圣诞节周的国际旅行计划
2023.我们将数据集中的城市设置为前十名20191年全球城市目的地，并获得Metabase2的景点信息。我们利用谷歌航班3收集这十个城市在2023年12月24日至2023年3月12日期间的航班信息。与TravelPlanner相比，我们省略了详细的交通方式、餐馆等信息，和住宿，但引入了有关航班和景点的详细限制。如图所示在表1中，不饱和圣诞节允许用户指定

1） 他们是否只想乘坐直达航班，2）他们喜欢的航空公司名单，3）景点名单他们喜欢的类别。我们收集了39个不满意的有4个可能原因的查询：直达航班规则不满足、飞行航空公司要求不满足、景点类别要求不满足，
预算不够。在39个查询中，有12个失败由于一个原因，18由于两个原因而失败，8由于三个原因而失败，1个由于四个原因而故障原因。有13个查询具有单个目的地城市，13个查询有两个，13个有三个。在里面此外，为了测试交互式计划修复性能，我们还修改了训练中的12个查询TravelPlanner的设置不令人满意。

5实验结果

我们研究了TravelPlanner和UnsatureChristmas的框架。我们使用GPT-4（Achiam等人，2023），温度为0作为我们的LLM默认，我们还将其与克劳德3作品进行比较-20240229（cla）和温度为0的Mixtral Large（mix），用于满意的计划解决评估。我们使用Z3求解器（De Moura和Bjørner，2008）作为我们的所有实验的SMT求解器。

5.1可满足计划解决评估

我们研究我们的框架可以创建多好可满足自然语言查询的旅行计划基于TravelPlanner基准。我们设计示例指令步骤和相应代码使用TravelPlanner培训中的三个查询使用训练集中的其他查询设置和调整提示。我们在验证集（180个可满足查询）和测试集（1000可满足的查询）。尽管我们框架对验证和测试集的评估是相同的，我们报告验证和测试集中的结果以更好地进行比较。
评估指标遵循Xie等人（2024），评估指标包括：1）交付率：衡量最终计划是否在时间有限；2） 常识约束通行证Rate：评估LLM是否通过常识约束；3） 硬约束通过率：评估LLM是否通过硬约束；4） 最终通过率：表示LLM是否通过所有约束。请参阅表1TravelPlanner的限制。有关常识的详细类别，请参阅附录B约束和硬约束以及微观和宏观评估模式的详细描述。
Baselines Xie等人（2024）在TravelPlanner上评估了传统基于规则的策略和各种LLM规划方法的性能。我们将我们的框架与使用不同策略的三个最强模型进行比较。贪婪搜索使用传统的搜索算法，引入启发式算法将总成本作为优化目标。TwoStage（GPT-4），最强大的型号在两阶段工具使用框架中，使用ReAct收集信息（Yao et al.，2022），并给出根据收集的信息制定计划。直接（GPT-4） ，唯一规划中最强大的模型框架，已经可以访问所有必要的预先收集信息并给出计划工具调用需求。验证的有效性我们的框架在各种LLM中，我们还评估我们的框架与克劳德3 Opus和MixtralLarge。我们调整提示与训练集和对验证集进行评估。我们将更改包括在内与我们的（GPT-4）相比，我们做出了改变见附录C.1.4。由于计算资源和成本考虑，我们只评估了两个新的具有180个查询的验证集上的LLM。
结果和分析表2显示了性能超过令人满意的比较结果查询。由于某些查询在这方面具有挑战性他们几乎没有可行的计划，我们限制了SMT求解器
每个查询的最大运行时间为30分钟如果达到该限制，则暂停程序。这个
我们的GPT-4验证集和测试集的交付率分别为99.4%和97.2%。从结果来看，我们可以观察到，两种LLM规划方法，TwoStage（GPT-4）和Direct（GPT–4），难以将所有约束条件都考虑在内合格率分别为0.6%和4.4%。此外，的结果贪婪搜索表明，在没有正式规范的情况下，基于启发式的方法无法通过任何的任务。我们的（GPT-4），具有将问题正式编码为SMT问题，实现了98.9%的高最终通过率验证集和测试集分别为97.0%。这证明了我们的框架在解决旅行计划问题的可满足查询方面的稳健性。在里面此外，我们的（Mixtral Large）交付率为85.0%，最终通过率为84.4%我们的（Claude-3）达到了交付率和最终合格率98.3%。我们的（Claude-3）可以到达与我们的结果（GPT-4）相当。虽然我们（Mixtral Large）的交货率下降了14.4%与我们的（GPT-4）相比，它仍然显著优于TwoStage（GPT-4）和Direct（GPT-4） ，并且99.2%的交付计划是正确的。

表2：验证集中180个查询和测试集中1000个查询的可满足查询的性能比较。Greedy Search、TwoStage和Direct的结果来自Xie等人。（2024）
我们讨论了我们的主要失败案例（Mixtral Large）见附录C.1.5。这些结果
展示了我们的框架对其他LLM。

5.2交互式计划维修评估

我们检查了我们的框架对来自的两个修改后的查询的交互式计划修复能力
TravelPlanner和UnsatisChristmas。
评估指标我们评估我们的框架基于成功率：LLM最终是否成功
修改约束以成功交付在有限的迭代次数内的可行计划。实施细节不满意圣诞节的不满意约束有四种不满意模式：1）预算不足，2）所需不存在直达航班，3）所需航空公司不存在，4）所需景点类别不存在。我们用测试我们的框架模仿用户。除了同意的用户对于LLM提出的所有建议，我们都有用户他们对预算有严格的限制，不停地航班、航空公司、景点类别、目的地城市，分别地他们将拒绝任何关于改变他们的硬性约束，并提供反馈指示它们不会改变该信息。我们修改的不可满足约束TravelPlanner有三种不令人满意的模式：1）预算不足，2）所需的交通方式不存在，3）所需房屋类型不存在。模拟用户在预算、目的地城市和交通方面受到严格限制方法和房屋类型。我们限制LLM采取最多十次迭代以提供十个建议。我们
包括附录C.2中的提示。
消融研究我们框架是1）LLM从求解器接收不可满足的原因；2） LLM收集信息基于原因，然后分析并提出建议；3） LLM接收人类偏好关于提出的建议；4） LLM修改编码问题的代码；5） SMT求解器给出了可满足或不可满足的验证。我们表演消融研究来检查这些关键部件。
我们比较以下内容：
•没有理由。此基线评估需求通过要求LLM解决不可满足的查询而不提供
无法满足的原因。
•无反馈。此基线测试该框架包含人类反馈和不提供人为反馈的偏好
LLM的建议。相反，它只提供二进制“同意”或“不同意”。
•无解算器。此基线通过移除SMT来检查工具使用的重要性求解器。LLM收集信息并只列出一次迭代的建议因为它无法调用解算器进行验证更新后的查询。
•我们的。我们的方法如3.2所述
•我们的-20。我们方法的一个变化最大迭代次数为20次。
结果和分析表3和表4显示交互式计划修复性能的结果。我们的框架可以解决不同的人偏好，平均为78.6%和85.0%。

所有类型的模仿人类。我们的-20，我们方法的一个变体，它增加了
最大建议迭代次数为20次世代时间的权衡，可以提高成功率分别为81.6%和91.7%。这显示了潜力增加迭代极限以实现更好后果对于TravelPlanner和圣诞节不满意，我们的表现明显优于无解算器平均为53.4%和60.0%
所有类型的模仿人类。这表明LLM利用SMT求解器的能力验证修改后的查询在很大程度上受益交互式计划修复过程。我们的平均跑赢《无理由》14.9%和5.0%，并且优于无反馈所有类型的平均值分别为7.8%和14.1%
模仿人类。这些结果验证了我们的关键组成部分的有效性。

5.3对看不见的约束的概括

由于旅行计划问题涉及不同类型的各种约束，我们的示例说明步骤可能不够全面涵盖所有可能的限制。在这里我们检查通过测试是否可以概括为未显示的约束类型在提示示例中。如表1所示，我们将非饱和圣诞节设计为具有不同的约束条件作为TravelPlanner。我们通过添加几个JSON步骤生成提示中的任务描述行，LLM可以生成指令在不带的情况下UnsatachChristmas中执行新查询的步骤需要添加新的示例。图3显示了我们的框架编码了不满足圣诞节中看不见的约束。

图3：JSON步骤提示如何泛化到看不见的约束的示例。黄色背景的文本是看不见的约束类型，以及带绿色的文本背景是相应的生成步骤。
请参见附录C.3增加了任务描述，完整内容见附录D从JSON输入生成的步骤。

6结论

在这项工作中，我们提出了一个框架，使LLM利用SMT求解器来形式化地制定并作为SMT问题。我们的框架可以概括为自然语言查询输入，如果查询满足通过率97%，并且可以与交互工作如果输入查询不可满足，则人工修改输入查询。最后，我们展示了我们的框架可以在没有的情况下推广到看不见的约束类型需要向promp添加新的示例。

7局限

工作的局限性和潜在风险是如下所示：
提示设计我们需要仔细和具体指令步骤和相应代码的设计以对问题进行编码。从头开始制定这个问题很耗时。然而我们的框架有可能推广到看不见的限制，从而缓解未来所需的努力在框架中加入更多的约束。
解算器运行时用于具有更多功能的大型数据库目的地城市选择、各种约束类型，以及只有很少可行计划的查询，我们框架可能需要很长的运行时间才能找到计划。为了缓解这种限制，一种潜在的方法是引入一些启发式方法，并对首先要验证的选项。
风险数据由于我们的所有信息来源框架来自我们使用的数据库，它目前不具备区分不安全的能力或不正确的信息。的一个潜在风险我们的框架是，它可能会产生有风险的计划基于数据库中的不安全信息。

A输入查询和输出计划示例

在查询中，用户可以指定1）行程长度（3、5或7天），2）目的地城市或州（对于5/7天的旅行，目的地城市将是一个州的2/3个城市），3）旅行日期，4）预算，5） 关于交通方式的偏好，6）关于餐厅烹饪类型的偏好，7）关于住宿类型和规则的偏好。
我们列出了一个示例输入查询和相应的输出计划。
输入查询：
你能为3人一组创建一个5天的旅行行程吗？从亚特兰大出发，访问2
2022年3月3日至3月7日明尼苏达州的城市？我们的预算是7900美元。我们需要允许聚会的住宿，理想情况下应该是整个房间。尽管我们不打算
自驾游，我们希望能够灵活地举办派对。
相应的输出计划：
{
“天”：1，
“current_city”：“从亚特兰大到明尼阿波利斯（明尼苏达州）”，
“交通”：“从亚特兰大到明尼阿波利斯（明尼苏达州）的出租车，持续时间：16小时26分钟，
距离：1821公里，成本：1821“，
早餐
“景点”：“明尼阿波利斯雕塑花园，明尼阿波利斯（明尼苏达州）”，
午餐
“晚餐”：“巴瓦鸡，明尼阿波利斯（明尼苏达州）”，
“住宿”：“光线充足的公寓在伟大的地区，关闭2所有！，明尼阿波利斯（明尼苏达州）”
},
{
“天”：2，
“current_city”：“从明尼阿波利斯（明尼苏达）到圣克劳德（明尼苏达）”，
“交通”：“从明尼阿波利斯（明尼苏达）到圣克劳德（明尼苏达）的出租车，持续时间：1小时6
分钟，距离：105公里，费用：105“，
“早餐”：“朋友餐厅，圣克劳德（明尼苏达州）”，
“景点”：“黑光探险，圣克劳德（明尼苏达州）”，
“午餐”：“马德拉斯咖啡馆，圣克劳德（明尼苏达州）”，
“晚餐”：“Aggarwal’s Sweets Paradise，St.Cloud（明尼苏达州）”，
“住宿”：“格拉梅西东区，圣克劳德（明尼苏达州）”
},
{
“天”：3，
“current_city”：“圣克劳德（明尼苏达州）”，
运输
“早餐”：“摩卡，圣克劳德（明尼苏达州）”，
“景点”：“AirMaxx蹦床公园和勇士球场，圣克劳德（明尼苏达州）”，
“午餐”：“下议院，圣克劳德（明尼苏达州）”，
“晚餐”：“Cakewalk-公园广场，圣克劳德（明尼苏达州）”，
“住宿”：“格拉梅西东区，圣克劳德（明尼苏达州）”
},
{
“天”：4，
“current_city”：“圣克劳德（明尼苏达州）”，
运输“早餐”：“Pa Pa Ya，圣克劳德（明尼苏达州）”，
“景点”：“Beaver Island Trail South，St.Cloud（明尼苏达州）”，
“午餐”：“Grecian Key Restaurant，St.Cloud（明尼苏达州）”，
“晚餐”：“食品保健，圣克劳德（明尼苏达州）”，
“住宿”：“格拉梅西东区，圣克劳德（明尼苏达州）”
},
{
“天”：5，
“current_city”：“从明尼苏达州圣克劳德到亚特兰大”，
“交通”：“从明尼苏达州圣克劳德到亚特兰大的出租车，持续时间：17小时19分钟，距离：
1919公里，成本：1919”，
“早餐”：“Annapurna Sweets，St.Cloud（明尼苏达州）”，
吸引力
“午餐”：“鸡肉共和国，圣克劳德（明尼苏达州）”，
晚餐
住处
}

B可满足计划解决评估细节

（Xie et al.，2024）中定义的常识约束包括：计划中的所有信息都在封闭范围内沙盒，计划是完整的，没有任何遗漏的部分，所有活动都应该在当前城市进行，旅行路线合理，餐厅和景点不应重复，交通合理（如果在旅行中乘坐出租车或航班，则不得自驾），在特定住宿必须满足其要求的最低住宿天数。硬性限制包括：旅行的总支出在预算范围内，指定的房间规则确实如此不存在（“禁止聚会”、“禁止吸烟”、“不允许10岁以下儿童”、“不得携带宠物”和“禁止访客”）指定的房间类型存在（“整间”、“私人房间”、“共享房间”和“无共享房间”），指定的菜肴类型在旅途中得到满足（“中国菜”、“美国菜”、《意大利菜》、《墨西哥菜》、，“印度”、“地中海”和“法国”），满足指定的运输方式（“禁止飞行”以及“禁止自动驾驶”。）。
对于常识约束通过率和硬约束通过率，有两种评估模式，微观和宏观，用于测试代理遵循单个约束和整体遵循约束的能力。Micro计算传递的约束与约束总数的比率，而Macro计算通过所有常识性或硬性约束的计划在所有测试计划中的比例。

C提示

C.1满足方案解决的提示

C.1.1 NL-JSON提示

提供了自然语言到JSON翻译提示的指令提示如下：
请帮助我从给定的自然语言文本中提取有效信息并重建它是JSON格式的，如下面的示例所示。在JSON中，“org”表示出发城市。“dest”表示目的地城市。“天”表示旅行总天数。当“天”超过3时，“visiting_city_number”指定目的地州中要覆盖的城市数。“日期”包括访问的详细日期。此外，“local_contraint”包含四个可能的约束。“房子”的可能选择规则”包括[“聚会”、“吸烟”、“10岁以下儿童”、“宠物”、“访客”]。可能的选项的“美食”包括[“中国”，“美国”，“意大利”，“墨西哥”，“印度”，“地中海”，法语“户型”的可能选项包括[“整间”、“私人房间”、“共享房间”，“非共享房间”]。“交通”的可能选项包括[“无航班”、“无自动驾驶”]。如果文本中均未提及，请将值设为null。
以下是三个示例：
––示例1–
文本：请帮我计划从3月16日起从圣彼得堡到罗克福德的3天旅行至2022年3月18日。旅行应计划为一个人，预算为1700美元。
JSON：
{
“org”：“圣彼得堡”，
“dest”：“Rockford”，
“天”：3，
“visiting_city_number”：1，
“日期”：[“2022-03-16”，“2022-03-1 7”，“202 2-03-18”]，
“people_number”：1，
“local_contraint”：{
“内部规则”：null，
“美食”：空，
“房型”：空，
“运输”：空
},
“预算”：1700
}
––示例2–
文本：｛请为两个人创建一个从劳德代尔堡开始到结束的3天旅行行程2022年3月8日至10日在密尔沃基举行。我们的旅行预算定为1100美元。我们会喜欢在旅途中体验美国和中国美食
JSON：
{
“org”：“劳德代尔堡”，
“dest”：“Milwaukee”，
“天”：3，
“visiting_city_number”：1，
“日期”：[“2022-03-08”，“2022-02-09”，“202 2-03-10”]，
“people_number”：2，
“local_contraint”：{
“内部规则”：null，
“美食”：[“美式”，“中式”]，
“房型”：空，
“运输”：空
},
“预算”：1100
}
––示例3—
文本：｛您能为3人一组创建一个5天的旅行行程吗？从亚特兰大出发，前往2022年3月3日至3月7日明尼苏达州的2个城市？我们的预算是7900美元。我们需要允许聚会的住宿，理想情况下应该是整个房间。尽管我们不打算自驾游，我们希望能够灵活地举办派对。}
JSON：
{
“org”：“亚特兰大”，
“dest”：“Minnesota”，
“天”：5，
“visiting_city_number”：2，
“日期”：[“2022-03-03”、“2022-02-04”、“202 2-03-05”、“2022 2-03-06”、“2020 2-03-07”]，
“people_number”：3，
“local_contraint”：{
“家庭规则”：“聚会”，
“美食”：空，
“房间类型”：“整个房间”，
“交通”：“禁止自驾”
},
“预算”：7900
}
––示例结束––
文本：｛query｝
JSON：

C.1.2 JSON步骤提示

JSON描述到步骤翻译提示的指令提示如下：
为您提供了一个JSON格式的旅行计划问题的约束条件。在JSON中，“org”表示出发城市。当总行程天数为5或7时，“dest”表示目的地状态；当总行程天数为3时，“dest”表示目的地城市。“天”表示旅行总天数。当“天”等于5或7时，“visiting_city_number”指定目的地状态中要覆盖的城市的数量。“日期”包括到的具体日期参观此外，“local_contraint”包含四个可能的约束。“房子”的可能选择规则”包括[“聚会”、“吸烟”、“10岁以下儿童”、“宠物”、“访客”]。可能的选项的“美食”包括[“中国”，“美国”，“意大利”，“墨西哥”，“印度”，“地中海”，法语“户型”的可能选项包括[“整间”、“私人房间”、“共享房间”，“非共享房间”]。“交通”的可能选项包括[“无航班”、“无自动驾驶”]。如果JSON中的字段值为null，不包括此特定的硬约束。您的工作是提供详细的分步说明，将此约束编码为代码。以下是针对不同约束的一些示例步骤：
––示例1–

JSON约束：
{
“org”：“亚特兰大”，
“dest”：“Minnesota”，
“天”：5，
“visiting_city_number”：2，
“日期”：[“2022-03-03”、“2022-02-04”、“202 2-03-05”、“2022 2-03-06”、“2020 2-03-07”]，
“people_number”：3，
“local_contraint”：{
“家庭规则”：“聚会”，
“美食”：空，
“房间类型”：“整个房间”，
“交通”：“禁止自驾”
},
“预算”：7900
}
步骤：
#目的地城市#
#运行CitySearch，从始发地“亚特兰大”获取明尼苏达州所有可能的目的地城市，
删除来源“Atlanta”（如果它在列表中）
#2个目的地城市的环路
#初始化Z3解算器
#将“城市”变量设置为2个目的地城市的索引
#如果city__0_index和city__1_index不相同，则断言2个“city”变量等于城市索引
#出发日期#
#为城市之间的3个运输设置“departure_dates”变量
#断言第一次运输发生在第一天（第0天），最后一次运输发生于最后一天（第4） ，第二次运输可能在其间的任何一天发生
#运输方式#
#为城市之间的3种交通方式设置交通方式（航班、自动驾驶、出租车）变量
#断言城市之间的三种交通方式仅使用航班、自动驾驶或出租车中的一种，
如果使用出租车或航班进行任何交通，则自动驾驶无效
#断言城市之间的所有3种交通方式都不是自动驾驶
#航班信息#
#运行FlightSearch以获取亚特兰大作为始发地的航班信息、城市列表、city_0和city_1以及日期
#获取以亚特兰大为始发地和最终目的地的具体航班价格信息，具体城市变量，
3次运输的出发日期
#为3个运输设置“flight_index”变量
#如果乘坐航班，断言3个“flight_index”变量在有效范围内，断言航班指数为-1
如果不乘坐飞机
#根据航班指数变量计算3人3次运输的航班价格
#以亚特兰大为出发地和最终目的地、特定城市和
3次运输的出发日期
#基于飞行指数变量计算3次运输的航班到达时间
#驾驶信息#
#运行DistanceSearch以获取亚特兰大作为原点以及city_0和city_1的驾驶信息
#以亚特兰大为出发地和最终目的地、特定城市和
3次运输的出发日期
#如果驾驶，则断言驾驶信息不为空
#根据行驶距离计算3人和3种交通工具的自动驾驶和出租车价格
#以亚特兰大为出发地和最终目的地、特定城市和出发地，获取驾驶到达时间
3次运输的日期
#餐厅信息#
#根据3次交通、5个总旅行日和出发时间，获取每天的到达和城市列表
日期变量
#运行RestaurantSearch以获取city_0和city_1的餐厅价格信息和美食信息
#为15顿饭（每天3顿，5天）设置“restaurant_in_which_city”变量
#对于每个“restaurant_in_which_city”变量，将其断言为基于当前城市或下一个城市
运输到达时间
#为15顿饭（每天3顿，5天）设置“restaurant_index”变量
#对于每个“restaurant_in_in_which_city”变量，获取具体的价格信息，
断言指数在有效范围内，断言同一城市的餐馆不重复，并计算
3人餐厅价格
#根据餐厅指数计算餐厅价格
#景点信息#
#运行AttractionSearch获取city_0和city_1的景点信息
#为5个（每天1个）景点设置“吸引_输入_城市”变量
#对于每个“吸引_城市_城市”变量，将其断言为基于当前城市或下一个城市
运输到达时间
#为5个（每天1个）景点设置“吸引指数”变量
#对于每个“吸引指数”，根据城市变量的吸引力获得特定的长度信息，
断言索引在有效范围内，并且同一城市的属性不重复
#住宿信息#
#运行住宿搜索以获取的住宿信息和住宿限制
城市0和城市1
#为2个（每个城市1个）住宿设置“住宿_索引”变量
#对于每个“住宿指数”，根据所在城市的住宿获得具体的价格信息
变量，断言“accommodation_index”变量在有效范围内，计算房间数
3人的需求和住宿价格
#对于每个城市，获取住宿最低夜间信息，并断言其少于住宿天数
在这个城市
#对于每个“住宿_索引”，获取特定的房间类型和房屋规则信息，断言“完整”
home/apt'存在于所有住宿中，断言“无派对”并不存在于所有的住宿中
预算
#将预算限额变量设置为7900
#加上3个运输价格，根据运输方式是否为航班，
自动驾驶或出租车
#将餐厅价格添加到已消费
#将住宿价格添加到支出中
#断言当前支出在预算范围内
--–示例2--
JSON约束：
{
“org”：“印第安纳波利斯”，
“dest”：“Colorado”，
“天”：7，
'visiting_city_number'：3，
“日期”：[‘2022-03-11’，‘2022-03-1 2’，‘2022年2月3日’，‘2020年2月14日’，’2022-03-15’，‘2021年2月16日’，
’2022-03-17’],
'people_number'：5，
“本地约束”：{
“家庭规则”：“宠物”，
“美食”：[“墨西哥”、“意大利”、“地中海”、“印度”]，
'房间类型'：'整个房间'，
“运输”：无
},
“预算”：15100
}
步骤：
#目的地城市#
#运行CitySearch，从原产地“印第安纳波利斯”获取科罗拉多州所有可能的目的地城市，
删除来源“Indianapolis”（如果它在列表中）
#3个目的地城市的环路
#初始化Z3解算器
#将“城市”变量设置为3个目的地城市的索引
#如果city_0_index、city_1_index和city_2_index不相同，则断言3个“city”变量等于city
指数
#出发日期#
#为城市之间的4个运输设置“departure_dates”变量
#断言第一次运输发生在第一天（第0天），最后一次运输发生于最后一天（第
6） ，第二次和第三次运输发生在两者之间，但不在同一天
#运输方式#
#为城市之间的4种交通方式设置交通方式（航班、自动驾驶、出租车）变量
#断言城市之间的4种交通方式仅使用航班、自动驾驶或出租车中的一种，
如果使用出租车或航班进行任何交通，则自动驾驶无效
#航班信息#
#运行FlightSearch以获取印第安纳波利斯作为始发地的航班信息、城市列表、city_0、city_1和
city_2和日期
#获取以印第安纳波利斯为始发地和最终目的地、特定城市的特定航班价格信息
可变，以及4次运输的出发日期
#为4个运输设置“flight_index”变量
#如果乘坐航班，断言4个“flight_index”变量在有效范围内，断言航班指数为-1
如果不乘坐飞机
#根据航班指数变量计算4次运输的5人航班价格
#以印第安纳波利斯为出发地和最终目的地、特定城市、，
4次运输的出发日期
#根据飞行指数变量计算4次运输的航班到达时间
#驾驶信息#
#运行DistanceSearch以获取印第安纳波利斯作为原点以及city_0、city_1和city_2的驾驶信息
#以印第安纳波利斯为出发地和最终目的地、特定城市、，
4次运输的出发日期
#如果驾驶，则断言驾驶信息不为空
#根据行驶距离计算5人和4种交通工具的自动驾驶和出租车价格
#以印第安纳波利斯为出发地和最终目的地、特定城市和
4次运输的出发日期
#餐厅信息#
#根据4种交通方式、7个总旅行日和出发时间，获取每天的到达和城市列表
日期变量
#运行RestaurantSearch以获取city_0、city_1和city_2的餐厅价格信息和美食信息
#为21顿饭（每天3顿，7天）设置“restaurant_in_which_city”变量
#对于每个“restaurant_in_which_city”变量，将其断言为基于当前城市或下一个城市
运输到达时间
18#为21顿饭（每天3顿，7天）设置“restaurant_index”变量
#对于每个“restaurant_in_in_which_city”变量，获取具体的价格信息，
断言指数在有效范围内，断言同一城市的餐馆不重复，并计算
5人餐厅价格
#为所需的每种烹饪类型设置“cuisine_type”变量
#对于每种烹饪类型，遍历所有餐厅，检查是否满意
#景点信息#
#运行AttractionSearch获取city_0、city_1和city_2的景点信息
#为7个（每天1个）景点设置“吸引_输入_城市”变量
#对于每个“吸引_城市_城市”变量，将其断言为基于当前城市或下一个城市
运输到达时间
#为7个（每天1个）景点设置“吸引指数”变量
#对于每个“吸引指数”，根据城市变量的吸引力获得特定的长度信息，
断言索引在有效范围内，并且同一城市的属性不重复
#住宿信息#
#运行住宿搜索以获取的住宿信息和住宿限制
城市0、城市1和城市2
#为3个（每个城市1个）住宿设置“住宿_索引”变量
#对于每个“住宿指数”，根据所在城市的住宿获得具体的价格信息
变量，断言“accommodation_index”变量在有效范围内，计算房间数
5人的需求和住宿价格
#对于每个城市，获取住宿最低夜间信息，并断言其少于住宿天数
在这个城市
#对于每个“住宿_索引”，获取特定的房间类型和房屋规则信息，断言“完整”
home/apt'存在于所有住宿中，断言“没有宠物”并不存在于所有的住宿中
预算
#将预算限额变量设置为15100
#加上4个运输价格，根据运输方式是否为航班，
自动驾驶或出租车
#将餐厅价格添加到已消费
#将住宿价格添加到支出中
#断言当前支出在预算范围内
--–示例3--
JSON约束：
{
“org”：“劳德代尔堡”，
“dest”：“Milwaukee”，
“天”：3，
“visiting_city_number”：1，
“日期”：[“2022-03-08”，“2022-02-09”，“202 2-03-10”]，
“people_number”：2，
“local_contraint”：{
“内部规则”：null，
“美食”：[“美式”，“中式”]，
“房型”：空，
“运输”：“无航班”
},
19“预算”：1100
}
步骤：
#目的地城市#
#将城市设置为列表仅包括密尔沃基
#循环通过1个目的地城市的城市
#初始化Z3解算器
#将“city”变量设置为1个目的地城市的索引
#断言“city”变量等于城市索引
#出发日期#
#为两个城市之间的交通设置“departure_dates”变量
#断言第一次运输发生在第一天（第0天），最后一次运输发生于最后一天（第2天）
#运输方式#
#为城市之间的2种交通方式设置交通方式（航班、自动驾驶、出租车）变量
#断言城市之间的两种交通方式仅使用航班、自动驾驶或出租车中的一种，
如果使用出租车或航班进行任何交通，则自动驾驶无效
#断言城市之间的所有2种交通工具都不是航班
#航班信息#
#运行FlightSearch以获取劳德代尔堡的航班信息作为始发地、城市列表、城市_0和日期
#获取以劳德代尔堡为始发地和最终目的地的具体航班价格信息，具体城市，
2次运输的出发日期
#为2个运输设置“flight_index”变量
#如果乘坐航班，断言2个“flight_index”变量在有效范围内，断言航班指数为-1
如果不乘坐飞机
#根据航班指数变量计算2人2次运输的航班价格
#获取以劳德代尔堡为始发地和最终目的地的具体航班到达时间信息，具体
城市，以及2次运输的出发日期
#根据飞行指数变量计算2次运输的航班到达时间
#驾驶信息#
#运行DistanceSearch以获取劳德代尔堡作为始发地和城市的驾驶信息_0
#以劳德代尔堡为出发地和最终目的地，获取特定的行驶距离信息
城市，以及2次运输的出发日期
#如果驾驶，则断言驾驶信息不为空
#根据行驶距离计算2人和2种交通工具的自动驾驶和出租车价格
#以劳德代尔堡为出发地和最终目的地、特定城市和
两次运输的出发日期
#餐厅信息#
#根据2次交通、3个总旅行日和出发时间，获取每天的到达和城市列表
日期变量
#运行RestaurantSearch以获取城市_0的餐厅价格信息和美食信息
#为9顿饭（每天3顿，3天）设置“restaurant_in_which_city”变量
#对于每个“restaurant_in_which_city”变量，将其断言为基于当前城市或下一个城市
运输到达时间
#为9顿饭（每天3顿，3天）设置“restaurant_index”变量
#对于每个“restaurant_in_in_which_city”变量，获取具体的价格信息，
20断言指数在有效范围内，断言同一城市的餐馆不重复，并计算
2人餐厅价格
#为所需的每种烹饪类型设置“cuisine_type”变量
#对于每种烹饪类型，遍历所有餐厅，检查是否满意
#景点信息#
#运行景点搜索以获取城市0的景点信息
#为3个（每天1个）景点设置“吸引力城市”变量
#对于每个“吸引城市”变量，根据断言其为当前城市或下一个城市
运输到达时间
#为3个（每天1个）景点设置“吸引指数”变量
#对于每个“吸引指数”，根据城市变量的吸引力获得特定的长度信息，
断言索引在有效范围内，并且同一城市的属性不重复
#住宿信息#
#运行住宿搜索以获取城市0的住宿信息和住宿限制
#为1个（每个城市1个）住宿设置“住宿指数”变量
#对于每个“住宿指数”，根据所在城市的住宿获得具体的价格信息
变量，断言“accommodationdex”变量在有效范围内，计算房间数量
需要2人和住宿价格
#对于每个城市，获取住宿最低夜间信息，并断言其少于住宿天数
在这个城市
预算
#将预算限制变量设置为1100
#加上2个运输价格，根据运输方式是否为航班，
自动驾驶或出租车
#将餐厅价格添加到已消费
#将住宿价格添加到支出中
#断言当前支出在预算范围内
--–示例结束--–
基于上面的例子，给出了遵循JSON约束的步骤。
注意保持示例中的格式，并以“#”开头包含步骤的每一行
JSON约束：｛JSON｝
步骤：

C.1.3 Step-Code prompt

The step to code example prompt for each constraint type is provided as follows:
Destination cities:

# Python script for testing satisfiability of the destination cities constraint of a travel plan problem.
# Run CitySearch to get all possible destination cities in Minnesota State from origin 'Atlanta', remove origin 'Atlanta' if it is
# in list
cities = CitySearch.run('Minnesota', 'Atlanta', query_json['date'])
if 'Atlanta' in cities:
cities.remove('Atlanta')
# Set cities to be a list includes Milwaukee only
cities = ['Milwaukee']
# Loop through cities for 2 destination cities
for city_0_index, city_0 in enumerate(cities):
for city_1_index, city_1 in enumerate(cities):
# Initialize Z3 solver s
s = Optimize()
# Set 'city' variable to be indexes of 2 destination cities
variables['city'] = [Int('city_' + str(i)) for i in range(2)]
# If city_0_index and city_1_index are not same, assert 2 'city' variables equal to city index
if city_0_index != city_1_index:
s.assert_and_track(variables['city'][0] == city_0_index, 'visit city in cities list')
21s.assert_and_track(variables['city'][1] == city_1_index, 'visit city in cities list')
# Loop through cities for 1 destination cities
for city_0_index, city_0 in enumerate(cities):
# Initialize Z3 solver s
s = Optimize()
# Set 'city' variable to be indexes of 1 destination cities
variables['city'] = [Int('city_' + str(i)) for i in range(1)]
# Assert 'city' variable equal to city index
s.assert_and_track(variables['city'][0] == city_0_index, 'visit city in cities list')
# Based on the examples above, in which the lines start with '#' is the instuction, where the line/lines below it before the
# next '#' is the corresponding code.
# For this below instruction, write corresponding code and respond instruction with code only. Start with ########## Destination
# cities response########## and end with ########## Destination cities response ends##########.

Departure Dates:

# Python script for testing satisfiability of the departure dates constraint of a travel plan problem.
# Set 'departure_dates' variables for 3 transportations between cities
variables['departure_dates'] = [Int('departure_dates_transportation_' + str(i)) for i in range(3)]
# Assert first transportation happens at first day (day 0), last transportation happens at last day (day 6), second and third
# transportation happen in between but not at the same day
s.assert_and_track(variables['departure_dates'][0] == 0, 'travel start date')
s.assert_and_track(And(variables['departure_dates'][1] > 0, variables['departure_dates'][1] < variables['departure_dates'][2]),
,→ 'valid travel date')
s.assert_and_track(And(variables['departure_dates'][2] > variables['departure_dates'][1], variables['departure_dates'][1] < 6),
,→ 'valid travel date')
s.assert_and_track(variables['departure_dates'][3] == 6, 'travel end date')
# Assert first transportation happens at first day (day 0), last transportation happens at last day (day 2)
s.assert_and_track(variables['departure_dates'][0] == 0, 'travel start date')
s.assert_and_track(variables['departure_dates'][2] == 2, 'travel end date')
# Based on the examples above, in which the lines start with '#' is the instuction, where the line/lines below it before the next
# '#' is the corresponding code.
# For this below instruction, write corresponding code and respond instruction with code only. Start with ########## Departure
# dates response########## and end with ########## Departure dates response ends##########.

Transportation Methods:

# Python script for testing satisfiability of the transportation methods constraint of a travel plan problem.
# Set transportation method variable (flight, self-driving, taxi) for 3 transportations between cities
variables['flight'] = [Bool('flight_travel_' + str(i)) for i in range(3)]
variables['self-driving'] = [Bool('self-driving_travel_' + str(i)) for i in range(3)]
variables['taxi'] = [Bool('taxi_travel_' + str(i)) for i in range(3)]
# Assert only one of flight, self-driving, or taxi is used for 3 transportations between cities, self-driving is not valid if taxi
# or flight is used for any transportation
s.assert_and_track(Or(variables['flight'][0], variables['self-driving'][0], variables['taxi'][0]), 'either flight, self-driving,
,→ or taxi for first transportation')
s.assert_and_track(Or(variables['flight'][1], variables['self-driving'][1], variables['taxi'][1]), 'either flight, self-driving,
,→ or taxi for second transportation')
s.assert_and_track(Or(variables['flight'][2], variables['self-driving'][2], variables['taxi'][2]), 'either flight, self-driving,
,→ or taxi for third transportation')
s.assert_and_track(Not(Or(And(variables['flight'][0], variables['self-driving'][0]), And(variables['flight'][0],
variables['taxi'][0]), And(variables['taxi'][0], variables['self-driving'][0]))), 'flight, self-driving, and taxi not
simutaneously for first transportation')
,→
,→
s.assert_and_track(Not(Or(And(variables['flight'][1], variables['self-driving'][1]), And(variables['flight'][1],
variables['taxi'][1]), And(variables['taxi'][1], variables['self-driving'][1]))), 'flight, self-driving, and taxi not
simutaneously for second transportation')
,→
,→
s.assert_and_track(Not(Or(And(variables['flight'][2], variables['self-driving'][2]), And(variables['flight'][2],
variables['taxi'][2]), And(variables['taxi'][2], variables['self-driving'][2]))), 'flight, self-driving, and taxi not
simutaneously for third transportation')
,→
,→
s.assert_and_track(Implies(Or(variables['flight'][0], variables['flight'][1], variables['flight'][2]),
Not(Or(variables['self-driving'][0], variables['self-driving'][1], variables['self-driving'][2]))), 'no self-driving if taken
flight for any transportation')
,→
,→
s.assert_and_track(Implies(Or(variables['taxi'][0], variables['taxi'][1], variables['taxi'][2]),
Not(Or(variables['self-driving'][0], variables['self-driving'][1], variables['self-driving'][2]))), 'no self-driving if taken
taxi for any transportation')
,→
,→
# Assert all 3 transportations between cities are not self-driving
s.assert_and_track(Not(variables['self-driving'][0]), 'no self-driving for first transportation')
s.assert_and_track(Not(variables['self-driving'][1]), 'no self-driving for second transportation')
s.assert_and_track(Not(variables['self-driving'][2]), 'no self-driving for third transportation')
# Based on the examples above, in which the lines start with '#' is the instuction, where the line/lines below it before the next
# '#' is the corresponding code.
# For this below instruction, write corresponding code and respond instruction with code only. Start with ########## Transportation
# response########## and end with ########## Transportation response ends##########.

Flight Information:

# Python script for testing satisfiability of the flight constraint constraint of a travel plan problem.
# Run FlightSearch to get flight info for Atlanta as origin, list of cities, city_0 and city_1, and dates
flight_info = FlightSearch.run_for_all_cities_and_dates('Atlanta', cities, [city_0, city_1], query_json['date'])
# Get specific flight price info with Atlanta as origin and final destination, specific city variable, and departure date for 3
# transportations
flight_0_price_list, flight_0_price_list_length = FlightSearch.get_info(flight_info, 'Atlanta', variables['city'][0],
,→ variables['departure_dates'][0], 'Price')
flight_1_price_list, flight_1_price_list_length = FlightSearch.get_info(flight_info, variables['city'][0], variables['city'][1],
,→ variables['departure_dates'][1], 'Price')
flight_2_price_list, flight_2_price_list_length = FlightSearch.get_info(flight_info, variables['city'][1], 'Atlanta',
,→ variables['departure_dates'][2], 'Price')
# Set 'flight_index' variable for 3 transportations
variables['flight_index'] = [Int('flight_{}_index'.format(i)) for i in range(3)]
# Assert 3 'flight_index' variables are within valid range if taking flight, assert flight index to be -1 if not taking flight
s.assert_and_track(Implies(variables['flight'][0], And(variables['flight_index'][0] >= 0,variables['flight_index'][0] <
,→ flight_0_price_list_length)), 'valid flight index for flight 0')
s.assert_and_track(Implies(variables['flight'][1], And(variables['flight_index'][1] >= 0,variables['flight_index'][1] <
,→ flight_1_price_list_length)), 'valid flight index for flight 1')
s.assert_and_track(Implies(variables['flight'][2], And(variables['flight_index'][2] >= 0,variables['flight_index'][2] <
,→ flight_2_price_list_length)), 'valid flight index for flight 2')
s.assert_and_track(Implies(Not(variables['flight'][0]), variables['flight_index'][0] == -1), 'valid flight index for flight 0')
s.assert_and_track(Implies(Not(variables['flight'][1]), variables['flight_index'][1] == -1), 'valid flight index for flight 1')
s.assert_and_track(Implies(Not(variables['flight'][2]), variables['flight_index'][2] == -1), 'valid flight index for flight 2')
# Calculate flight price for 2 people for 3 transportations based on flight index variable
flight_0_price = 2 * FlightSearch.get_info_for_index(flight_0_price_list, variables['flight_index'][0])
flight_1_price = 2 * FlightSearch.get_info_for_index(flight_1_price_list, variables['flight_index'][1])
flight_2_price = 2 * FlightSearch.get_info_for_index(flight_2_price_list, variables['flight_index'][2])
# Get specific flight arrival time info with Atlanta as origin and final destination, specific city, and departure date for 3
# transportations
flight_0_arrtime_list, _ = FlightSearch.get_info(flight_info, 'Atlanta', variables['city'][0], variables['departure_dates'][0],
,→ 'ArrTime')
flight_1_arrtime_list, _ = FlightSearch.get_info(flight_info, variables['city'][0], variables['city'][1],
,→ variables['departure_dates'][1], 'ArrTime')
flight_2_arrtime_list, _ = FlightSearch.get_info(flight_info, variables['city'][1], 'Atlanta', variables['departure_dates'][2],
,→ 'ArrTime')
# Calculate flight arrival time for 3 transportations based on flight index variable
flight_0_arrtime = FlightSearch.get_info_for_index(flight_0_arrtime_list, variables['flight_index'][0])
flight_1_arrtime = FlightSearch.get_info_for_index(flight_1_arrtime_list, variables['flight_index'][1])
flight_2_arrtime = FlightSearch.get_info_for_index(flight_2_arrtime_list, variables['flight_index'][2])
# Based on the examples above, in which the lines start with '#' is the instuction, where the line/lines below it before the next
# '#' is the corresponding code.
# For this below instruction, write corresponding code and respond instruction with code only. Start with ########## Flight
# response########## and end with ########## Flight response ends##########.

Driving Information:

# Python script for testing satisfiability of the driving constraint of a travel plan problem.
# Run DistanceSearch to get driving info for Atlanta as origin and city_0 and city_1
driving_info = DistanceSearch.run_for_all_cities('Atlanta', cities, [city_0, city_1])
# Get specific driving distance info with Atlanta as origin and final destination, specific city, and departure date for 3
# transportations
driving_0_distance, driving_0_length = DistanceSearch.get_info(driving_info, 'Atlanta', variables['city'][0], 'Distance')
driving_1_distance, driving_1_length = DistanceSearch.get_info(driving_info, variables['city'][0], variables['city'][1],
,→ 'Distance')
driving_2_distance, driving_2_length = DistanceSearch.get_info(driving_info, variables['city'][1],'Atlanta', 'Distance')
# Assert driving info is not empty if driving
s.assert_and_track(Implies(Or(variables['self-driving'][0], variables['taxi'][0]), driving_0_length > 0), 'driving is possible for
,→ transportation 0')
s.assert_and_track(Implies(Or(variables['self-driving'][1], variables['taxi'][1]), driving_1_length > 0), 'driving is possible for
,→ transportation 1')
s.assert_and_track(Implies(Or(variables['self-driving'][2], variables['taxi'][2]), driving_2_length > 0), 'driving is possible for
,→ transportation 2')
# Calculate self-driving and taxi price for 3 people and 3 transportations based on driving distance
self_driving_0_price = 0.05 * driving_0_distance * math.ceil(3 / 5)
self_driving_1_price = 0.05 * driving_1_distance * math.ceil(3 / 5)
self_driving_2_price = 0.05 * driving_2_distance * math.ceil(3 / 5)
taxi_0_price = driving_0_distance * math.ceil(3 / 4)
taxi_1_price = driving_1_distance * math.ceil(3 / 4)
taxi_2_price = driving_2_distance * math.ceil(3 / 4)
# Get driving arrival time with Atlanta as origin and final destination, specific city, and departure date for 3 transportations
driving_0_arrtime, _ = DistanceSearch.get_info(driving_info, 'Atlanta', variables['city'][0], 'Duration')
driving_1_arrtime, _ = DistanceSearch.get_info(driving_info, variables['city'][0], variables['city'][1], 'Duration')
driving_2_arrtime, _ = DistanceSearch.get_info(driving_info, variables['city'][1], 'Atlanta', 'Duration')
# Based on the examples above, in which the lines start with '#' is the instuction, where the line/lines below it before the next
# '#' is the corresponding code.
# Follow the variable names in examples.
# For this below instruction, write corresponding code and respond instruction with code only. Start with ########## Driving
# response########## and end with ########## Driving response ends##########.

Restaurant Information:

# Python script for testing satisfiability of the restaurant constraint of a travel plan problem.
# Get arrivals and city list for each day based on 3 transportations, 5 total travel day, and departure dates variables
transportation_0_arrtime = If(variables['flight'][0], flight_0_arrtime, driving_0_arrtime)
transportation_1_arrtime = If(variables['flight'][1], flight_1_arrtime, driving_1_arrtime)
transportation_2_arrtime = If(variables['flight'][2], flight_2_arrtime, driving_2_arrtime)
arrives = get_arrivals_list([transportation_0_arrtime, transportation_1_arrtime, transportation_2_arrtime], 5,
,→ variables['departure_dates'])
city_list = get_city_list(variables['city'], 5, variables['departure_dates'])
# Run RestaurantSearch to get restaurant price info and cuisine info for city_0 and city_1
restaurant_price, restaurant_cuisines = RestaurantSearch.run_for_all_cities(cities, [city_0, city_1])
# Run RestaurantSearch to get restaurant price info and cuisine info for city_0
restaurant_price, restaurant_cuisines = RestaurantSearch.run_for_all_cities(cities, [city_0])
# Set 'restaurant_in_which_city' variables for 15 (3 meals per day, 5 days) meals
variables['restaurant_in_which_city'] = [Int('restaurant_' + str(i)) for i in range(3*5)]
# For each 'restaurant_in_which_city' variable, assert it to be either current city or next city based on transportation arrivals
# time
for i, variable in enumerate(variables['restaurant_in_which_city']):
date_index = i // 3
meal_index = i % 3
if meal_index == 0: # breakfast
s.assert_and_track(Or(variable == city_list[date_index], variable == city_list[date_index+1]), 'eat in which city b')
s.assert_and_track(Implies(arrives[date_index]> 10, variable == city_list[date_index]),'eat in which city b')
s.assert_and_track(Implies(arrives[date_index]< 5, variable == city_list[date_index+1]),'eat in which city b')
if meal_index == 1: # lunch
s.assert_and_track(Or(variable == city_list[date_index], variable == city_list[date_index+1]), 'eat in which city l')
s.assert_and_track(Implies(arrives[date_index]> 15, variable == city_list[date_index]),'eat in which city l')
s.assert_and_track(Implies(arrives[date_index]< 10, variable == city_list[date_index+1]),'eat in which city l')
if meal_index == 2: # dinner
s.assert_and_track(Or(variable == city_list[date_index], variable == city_list[date_index+1]), 'eat in which city d')
s.assert_and_track(Implies(arrives[date_index]> 22, variable == city_list[date_index]),'eat in which city d')
s.assert_and_track(Implies(arrives[date_index]< 17, variable == city_list[date_index+1]),'eat in which city d')
# Set 'restaurant_index' variables for 15 (3 meals per day, 5 days) meals
variables['restaurant_index'] = [Int('restaurant_{}_index'.format(i)) for i in range(3*5)]
# For each 'restaurant_index', get specific price info based on 'restaurant_in_which_city' variable, assert index are within valid
# range, assert restaurants in same city are not repeated, and calculate restaurant price for 2 people
all_restaurant_price = 0
for i, variable in enumerate(variables['restaurant_index']):
restaurant_price_list, restaurant_list_length = RestaurantSearch.get_info(restaurant_price,
,→ variables['restaurant_in_which_city'][i], 'Price')
s.assert_and_track(Implies(variables['restaurant_in_which_city'][i] != -1, And(variable >= 0, variable <
,→ restaurant_list_length)), 'valid restaurant index')
s.assert_and_track(Implies(variables['restaurant_in_which_city'][i] == -1, variable == -1), 'valid restaurant index')
for j in range(i-1, -1, -1):
s.assert_and_track(Implies(And(variables['restaurant_in_which_city'][i] != -1, variables['restaurant_in_which_city'][i] ==
variables['restaurant_in_which_city'][j]), variable != variables['restaurant_index'][j]), 'non repeating restaurant
index')
,→
,→
Calculate restaurant price based on restaurant index
all_restaurant_price += 2 * If(variables['restaurant_in_which_city'][i] != -1,
,→ RestaurantSearch.get_info_for_index(restaurant_price_list, variable), 0)
# Set 'cuisine_type' variables for each cuisine type required
variables['cuisines_type'] = [Int('cuisines_' + i) for i in query_json['local_constraint']['cuisine']]
# For each cuisine type, iterate through all restaurant to check if it is satisfied
for index, cuisine in enumerate(query_json['local_constraint']['cuisine']):
count = 0
for i, variable in enumerate(variables['restaurant_index']):
restaurant_cuisines_list, _ = RestaurantSearch.get_info(restaurant_cuisines, variables['restaurant_in_which_city'][i],
,→ 'Cuisines')
count += If(RestaurantSearch.check_exists(cuisine, restaurant_cuisines_list, variable), 1, 0)
s.assert_and_track(variables['cuisines_type'][index] == count, cuisine + 'type restaurant')
s.assert_and_track(variables['cuisines_type'][index] > 0, cuisine + 'type restaurant is visited')
# Based on the examples above, in which the lines start with '#' is the instuction, where the line/lines below it before the next
# '#' is the corresponding code.
# For this below instruction, write corresponding code and respond instruction with code only. Start with ########## Restaurant
# response########## and end with ########## Restaurant response ends##########.

Attraction Information:

# Python script for testing satisfiability of the attraction constraint of a travel plan problem.
# Run AttractionSearch to get attraction info for city_0 and city_1
attraction_info = AttractionSearch.run_for_all_cities(cities, [city_0, city_1])
# Run AttractionSearch to get attraction info for city_0
attraction_info = AttractionSearch.run_for_all_cities(cities, [city_0])
# Set 'attraction_in_which_city' variables for 5 (1 per day) attractions
variables['attraction_in_which_city'] = [Int('attraction_' + str(i)) for i in range(1*5)]
# For each 'attraction_in_which_city' variable, assert it to be either current city or next city based on transportation arrivals
# time
for i, variable in enumerate(variables['attraction_in_which_city']):
s.assert_and_track(variable == If(arrives[i]> 18, city_list[i], city_list[i+1]), 'attraction in which city')
# Set 'attraction_index' variables for 5 (1 per day) attractions
variables['attraction_index'] = [Int('attraction_{}_index'.format(i)) for i in range(1*5)]
24# For each 'attraction_index', get specific length info based on attraction in which city variable, assert index are within valid
# range, and attrations in same city are not repeated
for i, variable in enumerate(variables['attraction_index']):
attraction_list_length = AttractionSearch.get_info(attraction_info, variables['attraction_in_which_city'][i])
s.assert_and_track(Implies(variables['attraction_in_which_city'][i] != -1, And(variable >= 0, variable <
,→ attraction_list_length)), 'valid attraction index')
s.assert_and_track(Implies(variables['attraction_in_which_city'][i] == -1, variable == -1), 'valid attraction index')
for j in range(i-1, -1, -1):
s.assert_and_track(Implies(And(variables['attraction_in_which_city'][i] != -1, variables['attraction_in_which_city'][i] ==
variables['attraction_in_which_city'][j]), variable != variables['attraction_index'][j]), 'non repeating attraction
index')
# Based on the examples above, in which the lines start with '#' is the instuction, where the line/lines below it before the next
# '#' is the corresponding code.
# For this below instruction, write corresponding code and respond instruction with code only. Start with ########## Attraction
# response########## and end with ########## Attraction response ends##########.

Accommodation Information:

# Python script for testing satisfiability of the accommodation constraint of a travel plan problem.
# Run AccommodationSearch to get accommodation info and accommodation constraints for city_0 and city_1
accommodation_info, accommodation_constraints = AccommodationSearch.run_for_all_cities(cities, [city_0, city_1])
# Run AccommodationSearch to get accommodation info and accommodation constraints for city_0
accommodation_info, accommodation_constraints = AccommodationSearch.run_for_all_cities(cities, [city_0])
# Set 'accommodation_index' variables for 2 (1 per city) accommodations
variables['accommodation_index'] = [Int('accommodation_{}_index'.format(i)) for i in range(2)]
# For each 'accommodation_index', get specific price info based on accommodation in which city variable, assert
# 'accommodation_index' variable are within valid range, calculate number of room need for 2 people and accommodation price
all_accommodation_price = 0
for i, variable in enumerate(variables['accommodation_index']):
accommodation_price_list, accommodation_list_length = AccommodationSearch.get_info(accommodation_info, variables['city'][i],
,→ 'Price')
s.assert_and_track(And(variable >= 0, variable < accommodation_list_length), 'valid accomodation index')
accommodation_maximum_occupancy_list, _ = AccommodationSearch.get_info(accommodation_info, variables['city'][i],
,→ 'Maximum_occupancy')
num_room = convert_to_int(RealVal(2) / AccommodationSearch.get_info_for_index(accommodation_maximum_occupancy_list, variable))
all_accommodation_price += (variables['departure_dates'][i+1] - variables['departure_dates'][i]) * num_room *
,→ AccommodationSearch.get_info_for_index(accommodation_price_list, variable)
# For each city, get accommodation minimum night info and assert it to be less than the days stay in this city
for index, city in enumerate(variables['city']):
accommodation_minimum_nights_list, _ = AccommodationSearch.get_info(accommodation_info, city, 'Minimum_nights')
minimum_night = AccommodationSearch.get_info_for_index(accommodation_minimum_nights_list,
,→ variables['accommodation_index'][index])
s.assert_and_track(minimum_night <= variables['departure_dates'][index+1]- variables['departure_dates'][index], 'minimum
,→ nights satisfied')
# For each 'accommodation_index', get specific room type and house rules info, assert 'Entire home/apt' exist for all
# accommodations, assert 'No parties' does not exist for all accommodations
for i, variable in enumerate(variables['accommodation_index']):
accommodation_room_types_list, _ = AccommodationSearch.get_info(accommodation_constraints, variables['city'][i],
,→ 'Room_types')
accommodation_house_rules_list, _ = AccommodationSearch.get_info(accommodation_constraints, variables['city'][i],
,→ 'House_rules')
s.assert_and_track(AccommodationSearch.check_exists('Entire home/apt', accommodation_room_types_list, variable) == True,
,→ 'Entire home/apt' + 'types accomadation visited')
s.assert_and_track(AccommodationSearch.check_exists('No parties', accommodation_house_rules_list, variable) == False, 'No
,→ parties' + 'rules accomadation not visited')
# Based on the examples above, in which the lines start with '#' is the instuction, where the line/lines below it before the next
# '#' is the corresponding code.
# For this below instruction, write corresponding code and respond instruction with code only. Start with ########## Accommodation
# response########## and end with ########## Accommodation response ends##########.

Budget:

# Python script for testing satisfiability of the budget constraint of a travel plan problem.
# Set budget limit variable to be 7900
variables['budget_limit'] = RealVal(7900)
# Add 3 transportation price to spent, according to whether transportation method is flight, self-driving, or taxi
spent = 0
spent += If(variables['flight'][0], flight_0_price, If(variables['self-driving'][0], self_driving_0_price,
,→ If(variables['taxi'][0], taxi_0_price, 10000)))
spent += If(variables['flight'][1], flight_1_price, If(variables['self-driving'][1], self_driving_1_price,
,→ If(variables['taxi'][1], taxi_1_price, 10000)))
spent += If(variables['flight'][2], flight_2_price, If(variables['self-driving'][2], self_driving_2_price,
,→ If(variables['taxi'][2], taxi_2_price, 10000)))
# Add restaurant price to spent
spent += all_restaurant_price
# Add accommodation price to spent
spent += all_accommodation_price
# Assert current spent is within budget
25s.assert_and_track(spent <= variables['budget_limit'], 'budget enough')
# Based on the examples above, in which the lines start with '#' is the instuction, where the line/lines below it before the next
# '#' is the corresponding code.
# For this below instruction, write corresponding code and respond instruction with code only. Start with ########## Budget
# response########## and end with ########## Budget response ends##########.

C.1.4 GPT-4、Claude 3和Mixtral Large的即时差异

以GPT-4的提示为起点，我们调整提示（添加更多解释或示例），用于在TravelPlanner中设置训练的Claude-3和Mixtral Large。Claude-3几乎与GPT-4有相同的提示，除了JSON步骤提示。自年起训练集，Claude-3的一个失败案例是它无法正确处理“家庭规则”。当JSON将“家庭规则”指定为“10岁以下儿童”，这意味着旅行者有10岁以下的孩子我想住在没有“禁止10岁以下儿童”规定的住处。而Claude-3有时是不能在步骤中给出“没有10岁以下的孩子”，相反，它给出的步骤中有“10岁以下没有孩子”允许”。为了使其能够处理这一问题，我们添加了一句话的解释“如果提到了家庭则‘xxx’，
则不应存在所有住宿的“无xxx”。”在JSON步骤提示中。与Claude-3相比，Mixtral Large需要更迅速的调整：
•我们添加了“如果需要，您只能将null分配给本地约束。其他字段必须具有
价值观“到NL-JSON提示，因为Mixtral Large有时会错过JSON中的一些信息翻译
•Claude-3使用与Mixtral Large相同的JSON Step提示。
•我们在目的地城市步骤代码提示中添加了一个通过城市的3城市循环示例；我们增加了一个2城出发日期提示中的旅行日期断言示例；我们添加了一种单城市交通方式运输方法的断言示例；我们添加了要求LLM不要用于循环的指令并用“i”命名变量，因为当它试图用i迭代创建或访问变量时，它失败了写正确的代码。
从我们需要做出的改变数量来看，我们可以观察到Mixtral Large通常会生更多与GPT-4和Claude-3相比，代码生成错误，因此需要更多的示例和解释提示中提供。

C.1.5 Mixtral Large的故障案例

尽管我们使用训练集调整了提示，但仍有一些失败案例没有出现在因此对Mixtral Large的交付率产生了负面影响。主要失效模式为：“房间类型”取“无共享房间”值。这种房型在当指定了其他房间类型（如“私人房间”）时，生成的指令步骤应为“所有住宿都有私人房间”。但是，只有当提到“无共享房间”时步骤应该是“并非所有住宿都有共享房间”。因为“没有共享房间”并不存在出现在训练集或示例中，并且Mixtral Large不能推广到它，它通过产生“并非所有住宿都存在碎片房间”，因此无法搜索类型为“非共享房间”的住宅。
这是主要的故障模式，导致7.8%的交付计划失败（总计15.0%）。除了这种情况下，失败是由运行时问题或一些偶然的代码生成错误引起的。

C.2交互式计划修复提示

C.2.1建议提示

指导LLM收集信息、分析现状并提供的指令提示针对不可满足的查询提供如下建议：
不满意圣诞节的建议提示：

作为一名旅行规划师，您有一些JSON格式的约束条件来满足往返旅行计划
问题
旅行跨越“日期”，从“组织”出发，在其间的一排“目的地”城市旅行，然后返回
到“组织”
例如，如果“org”是city_0，“dest”是[city_1，city_2]，则航班可能是[city_0->city_1、city_1->city_2、city_2->city_0]或[city_0->city_2，city_2->city_1，city_1->city_0]
此外，“local_contraint”包含三个可能的约束。“飞行规则”指定是否是否需要“不间断”。“航空公司”指定用户可以接受的航空公司列表。可能的选项的“吸引类别”指定要参观的景点类别列表。如果字段值为null，则不包括此特定的硬约束。
所有航班都需要满足指定的“飞行规则”。所有航班都需要是接受的“航空公司”。需要满足“吸引_类别”中的所有类别，并且一个类别如果它存在于一个景点中，则可以满足。
在分析了这些约束之后，您发现它们在当前设置下是不可满足的。你会给出了令人不满意的理由。
根据原因收集信息，或者根据您收集的信息分析当前情况或对约束条件进行建议的修改。信息收集可以采取4种不同的操作：
（1） FlightSearch[出发城市，目的地城市]：描述：一个航班信息检索工具。
参数：
出发城市：你要飞出的城市。
目的地城市：您要到达的城市。
示例：FlightSearch[纽约市，伦敦]将获取从纽约市到伦敦的航班。
（2） AirlineSearch[航空公司]：
描述：查找输入航空公司的航班。
参数：航空公司-您要使用的航空公司名称。
示例：AirlineSearch[美联航]将返回美联航的所有航班。
（3） 景点搜索[城市]：
描述：在您选择的城市中查找景点类别。
参数：城市-您要寻找景点的城市的名称。
示例：AttractionSearch[伦敦]将返回伦敦的景点类别。
（4） CategorySearch[类别]：
描述：查找包含景点的城市输入类别。
参数：类别-您想要参观的景点类别。
示例：CategorySearch[公园]将返回公园类景点所在的所有城市。
你需要采取行动分析当前的情况，并在每次行动后计划未来的步骤FlightSearch、AirlineSearch、AttractionSearch或CategorySearch。
示例：分析[你对当前形势的分析和对未来的计划]
你可以建议取消直达限制，建议更换所需的航空公司，建议要更改目的地城市（但保持目的地城市数量不变），建议更改景点类别，或建议提高预算。不要提出其他改变其他的建议JSON输入中的字段，如来源、访问城市数量等。请给出合理的建议，只有当你认为你已经收集了足够的信息和建议很有可能令人满意。例如，如果目的地城市没有所需的景点类别，如果有信息，您应该建议更改目的地城市显示新城市具有所需类别
请尝试保留原始约束，并仅当原始约束是必要的。
示例：
建议[将预算提高到5000]
建议[将目的地城市更改为伊斯坦布尔和澳门]
建议[删除不间断约束]
建议[将航空公司改为联合航空、法国航空或捷蓝航空]
建议[将景点类别改为花园和博物馆]
可能的城市列表为[曼谷'，迪拜'，香港'，伊斯坦布尔'，吉隆坡'，“伦敦”、“澳门”、“纽约市”、“巴黎”、“新加坡”]
现在，根据输入的查询、不满意的原因和收集的信息，请给出下一个动作（只有一个动作）你只想在没有解释的情况下采取，你需要给出15次迭代内的建议：
输入查询：｛query｝
不满意的原因：｛原因｝
收集的信息：｛info｝

Suggestion prompt for TravelPlanner:

作为一名旅行规划师，您有一些JSON格式的约束条件来满足往返旅行计划
问题
旅行跨越“日期”，从“组织”出发，前往“目的地”城市，然后返回“组织”。例如，如果“org”是city_0，“dest”是city-1，则交通工具将是[city_0->city_1，city_1->城市_0]
此外，“local_contraint”包含四个可能的约束。“房子”的可能选择规则”包括[“聚会”、“吸烟”、“10岁以下儿童”、“宠物”、“访客”]。可能的选项的“美食”包括[“中国”，“美国”，“意大利”，“墨西哥”，“印度”，“地中海”，法语“户型”的可能选项包括[“整间”、“私人房间”、“共享房间”，“非共享房间”]。“交通”的可能选项包括[“无航班”、“无自动驾驶”]。如果
JSON中的字段值为null，不包括此特定的硬约束。
所有住宿都需要满足规定的“房屋规则”和“房屋类型”。这个所有运输都需要满足指定的“运输”要求。“美食”中的所有美食需要得到满足，如果一家餐厅有一道菜，那么它也可以得到满足。
在分析了这些约束之后，您发现它们在当前设置下是不可满足的。你会给出了令人不满意的理由。
根据原因收集信息，或者根据您收集的信息分析当前情况或对约束条件进行建议的修改。
信息收集可以采取6种不同的操作：
（1） DrivingCheck[出发城市，目的地城市]：描述：驾驶信息检查检查驾驶是否可行的工具。
参数：
出发城市：您将要开车离开的城市。
目的地城市：您要到达的城市。
示例：DrivingCheck[明尼阿波利斯大福克斯]将检查从大福克斯开车是否可行分叉到明尼阿波利斯。
（2） DrivingSearch[出发城市]：
描述：一个返回所有可到达城市的驾驶信息检索工具。
参数：
出发城市：您将要开车离开的城市。
示例：DrivingSearch[大福克斯]将通过返回所有从大福克斯到达的城市
驱动。
（3） FlightCheck[出发城市，目的地城市，日期]：
描述：一种飞行信息检查工具，用于检查飞行是否可行。
参数：
出发城市：你要飞出的城市。
目的地城市：您要到达的城市。
日期：您乘坐航班的日期。
示例：FlightCheck[大福克斯，明尼阿波利斯，2022-06-05]将检查飞行是否可行
2022-06-05从大福克斯到明尼阿波利斯。
（4） FlightSearch[出发城市，日期]：描述：航班信息检索工具
返回所有可到达的城市。
参数：
出发城市：你要飞出的城市。
日期：您乘坐航班的日期。
示例：FlightSearch【Grand Forks，2022-06-05】将从Grand返回所有可到达的城市
2022-06-05航班分叉。
（5） 住宿搜索[城市]：
描述：在您选择的城市中查找住宿类型。
参数：城市-您要住宿的城市的名称。
示例：住宿搜索〔Grand Forks〕将返回Grand中的住宿类别叉子。
（6） TypeSearch[类型]：
描述：查找包含输入类型住宿的城市。
参数：类型-您想参观的住宿类型。
示例：TypeSearch[整个房间]将返回整个房间类型住宿的所有城市
存在
你需要采取行动分析当前的情况，并在每次行动后计划未来的步骤DrivingCheck、DrivingSearch、FlightCheck、FlightSearch、AccommodationSearch或TypeSearch。
示例：分析[你对当前形势的分析和对未来的计划]
你可以建议取消“户型”限制，建议取消“交通”约束，建议改变目的地城市（但保持目的地城市数量不变），或者建议提高预算。不要给出更改JSON输入中其他字段的其他建议，例如来源、访问城市的数量等。请给出合理的建议，只有当你认为你已经收集了
足够的信息和建议很有可能令人满意。例如，如果目的地城市没有所需的住宿类型，如果信息显示新城市具有所需的类型。请尝试保留原始约束，并仅当原始约束是必要的。
示例：
建议[将预算提高到5000]
建议[将目的地城市改为明尼阿波利斯]
建议[删除户型限制]
建议[删除航班/无航班/无自动驾驶交通断言]
现在，根据输入的查询、不满意的原因和收集的信息，请给出你想采取的下一个行动（只有一个行动）——没有解释，你需要给出15次迭代内的建议：
输入查询：｛query｝
不满意的原因：｛原因｝
收集的信息：｛info｝

C.2.2建议无理由提示

建议无原因提示基本上是从建议提示修改而来的，删除了所有关于原因的描述。

C.2.3建议无Sovler提示

删除迭代求解器调用并直接引导LLM提供的指令建议提示
建议列表如下所示：
建议不满足圣诞节的Sovler提示：

作为一名旅行规划师，您有一些JSON格式的约束条件来满足往返旅行计划
问题
旅行跨越“日期”，从“组织”出发，在其间的一排“目的地”城市旅行，然后返回
例如，如果“org”是city_0，“dest”是[city_1，city_2]，那么航班可以是[城市_0->city_1，城市_1->city_2，城市_2->city_0]或[城市_0->城市_2，城市_2->城市_1，城市_1->城市_0]
此外，“local_contraint”包含三个可能的约束。“飞行规则”指定是否是否需要“不间断”。“航空公司”指定用户可以接受的航空公司列表。可能的“吸引类别”选项指定要参观的景点类别列表。如果字段值在JSON中为null，不包括此特定的硬约束。
所有航班都需要满足指定的“飞行规则”。所有航班都需要是接受的“航空公司”。需要满足“吸引_类别”中的所有类别，并且一个类别如果它存在于一个景点中，则可以满足。
在分析了这些约束之后，您发现它们在当前设置下是不可满足的。
收集信息，或者根据您收集的信息，分析当前情况或给出建议对约束条件进行修改。
信息收集可以采取4种不同的操作：
（1） FlightSearch[出发城市，目的地城市]：
描述：一个航班信息检索工具。参数：
出发城市：你要飞出的城市。
目的地城市：您要到达的城市。
示例：FlightSearch[纽约市，伦敦]将获取从纽约市到伦敦的航班。
（2） AirlineSearch[航空公司]：
描述：查找输入航空公司的航班。
参数：航空公司-您要使用的航空公司名称。
示例：AirlineSearch[美联航]将返回美联航的所有航班。
（3） 景点搜索[城市]：
描述：在您选择的城市中查找景点类别。
参数：城市-您要寻找景点的城市的名称。
示例：AttractionSearch[伦敦]将返回伦敦的景点类别。
（4） CategorySearch[类别]：
描述：查找包含景点的城市输入类别。
参数：类别-您想要参观的景点类别。
示例：CategorySearch[公园]将返回公园类景点所在的所有城市。
你需要采取行动分析当前的情况，并在每次行动后计划未来的步骤FlightSearch、AirlineSearch、AttractionSearch或CategorySearch。
示例：分析[你对当前形势的分析和对未来的计划]您可以建议取消直达限制，建议更改所需的航空公司，建议更改目的地城市（但保持目的地城市数量不变），建议改变景点类别，或建议增加预算。不要提出其他改变的建议JSON输入中的其他字段，如来源、访问城市数量等。只有当你认为你已经收集了约束条件时，请给出合理的建议来修改约束条件足够的信息和建议很有可能令人满意。例如，如果目的地城市没有所需的景点类别，如果有信息，您应该建议更改目的地城市显示新城市具有所需类别请尝试保留原始约束，并仅当原始约束是必要的。
如果你认为一个建议不够，你可以提出一个或多个建议。请将建议与；示例：
建议[将预算提高到5000]
建议[将目的地城市更改为伊斯坦布尔和澳门]
建议[删除不间断约束]
建议[将航空公司改为联合航空、法国航空或捷蓝航空]
建议[将景点类别改为花园和博物馆]
建议[将预算提高到3000；将目的地城市改为伦敦]
可能的城市列表为[曼谷'，迪拜'，香港'，伊斯坦布尔'，吉隆坡'，
“伦敦”、“澳门”、“纽约市”、“巴黎”、“新加坡”]现在，根据输入查询和收集的信息，请给出您想要采取的下一个行动（仅一个行动）解释，您需要在15次迭代中给出建议：
输入查询：｛query｝
收集的信息：｛info｝

建议不满足圣诞节的Sovler提示：

作为一名旅行规划师，您有一些JSON格式的约束条件来满足往返旅行计划
问题
旅行跨越“日期”，从“组织”出发，前往“目的地”城市，然后返回“组织”。例如，
如果“org”是city_0，“dest”是city-1，则交通工具将是[city_0->city_1，city_1->城市_0]
此外，“local_contraint”包含四个可能的约束。“房子”的可能选择规则”包括[“聚会”、“吸烟”、“10岁以下儿童”、“宠物”、“访客”]。可能的选项的“美食”包括[“中国”，“美国”，“意大利”，“墨西哥”，“印度”，“地中海”，法语“户型”的可能选项包括[“整间”、“私人房间”、“共享房间”，“非共享房间”]。“交通”的可能选项包括[“无航班”、“无自动驾驶”]。如果
JSON中的字段值为null，不包括此特定的硬约束。指定的“房子”规则”和“户型”需要满足所有住宿条件。指定的“交通”31需要通过所有运输方式来满足。“美食”中的所有美食都需要得到满足
如果一家餐厅有美食，那它就可以满足了。
在分析了这些约束之后，您发现它们在当前设置下是不可满足的。
收集信息，或者根据您收集的信息，分析当前情况或给出建议对约束条件进行修改。
信息收集可以采取6种不同的操作：
（1） DrivingCheck[出发城市，目的地城市]：描述：驾驶信息检查检查驾驶是否可行的工具。
参数：
出发城市：您将要开车离开的城市。
目的地城市：您要到达的城市。
示例：DrivingCheck[明尼阿波利斯大福克斯]
将检查从大福克斯到明尼阿波利斯的驾驶是否可行。
（2） DrivingSearch[出发城市]：
描述：一个返回所有可到达城市的驾驶信息检索工具。
参数：
出发城市：您将要开车离开的城市。
示例：DrivingSearch[大福克斯]将通过返回所有从大福克斯到达的城市驱动。
（3） FlightCheck[出发城市，目的地城市，日期]：
描述：一种飞行信息检查工具，用于检查飞行是否可行。
参数：
出发城市：你要飞出的城市。
目的地城市：您要到达的城市。日期：您乘坐航班的日期。
示例：FlightCheck[大福克斯，明尼阿波利斯，2022-06-05]将检查飞行是否可行2022-06-05从大福克斯到明尼阿波利斯。
（4） FlightSearch[出发城市，日期]：
描述：一个返回所有可到达城市的航班信息检索工具。
参数：
出发城市：你要飞出的城市。
日期：您乘坐航班的日期。
示例：FlightSearch【Grand Forks，2022-06-05】将从Grand返回所有可到达的城市2022-06-05航班分叉。
（5） 住宿搜索[城市]：
描述：在您选择的城市中查找住宿类型。
参数：城市-您要住宿的城市的名称。
示例：住宿搜索〔Grand Forks〕将返回Grand中的住宿类别叉子。
（6） TypeSearch[类型]：
描述：查找包含输入类型住宿的城市。
参数：类型-您想参观的住宿类型。
示例：TypeSearch[整个房间]将返回整个房间类型住宿的所有城市
存在
你需要采取行动分析当前的情况，并在每次行动后计划未来的步骤DrivingCheck、DrivingSearch、FlightCheck、FlightSearch、AccommodationSearch或TypeSearch。
示例：分析[你对当前形势的分析和对未来的计划]
您可以建议取消“户型”限制，建议取消“交通”限制，并建议更改目的地城市（但保留目的地城市数量不变），或建议提高预算。不要给出更改中其他字段的其他建议JSON输入，如来源、访问城市数量等。请给出合理的建议，只有当你认为你已经收集了足够的信息和建议很有可能令人满意。例如，如果目的地城市没有所需的住宿类型，如果信息显示新城市具有所需的类型。请尝试保留原始约束，并仅当原始约束是必要的。如果你认为一个建议不够，你可以提出一个或多个建议。请将建议与；示例：
建议[将预算提高到5000]
建议[将目的地城市改为明尼阿波利斯]
建议[删除户型限制]
建议[删除航班/无航班/无自动驾驶交通断言]
建议[将预算提高到2000年，将目的地城市改为芝加哥]
现在，根据输入的查询和收集的信息，请给出下一个操作（仅一个行动）你只想在没有解释的情况下采取行动，你需要在15分钟内给出建议迭代次数：
输入查询：｛query｝
收集的信息：｛info｝

C.2.4代码修改提示

作为一名旅行规划师，您有一些python代码来测试旅行计划问题的可满足性。
虽然现在一些约束已经更改，但您的任务是根据
以适应已更改的约束条件。
只更改代码中需要修改的部分，不添加任何新的部分。
请只回复代码，并确保包含完整的代码，而不是更新的代码行。
以##########响应#######开始，以#######结束#######应答结束###########。
原始代码：｛Codes｝
修改的约束：｛Constraints｝

C.3概括评价提示

为了测试我们的框架泛化到看不见的约束类型的能力，我们添加了以下任务描述并在步骤代码提示的末尾附加：

基于上面的例子，您可以给出以下JSON约束的步骤吗
领域。在输入的JSON中，“org”表示出发城市。“dest”表示目的地城市。
“天”表示旅行的总天数。当“天”等于5或7时。“日期”包括访问的具体日期。
此外，“local_contraint”包含三个可能的约束。“飞行规则”指定是否是否需要“不间断”。“航空公司”指定您可以接受的航空公司列表。可能的选项的“吸引类别”指定要参观的景点类别列表。“运输”是总是“飞行”。如果JSON中的字段值为null，则不包括此特定的硬约束。所有航班都需要满足指定的“飞行规则”。所有航班都需要是接受的“航空公司”。需要满足“吸引_类别”中的所有类别，并且一个类别如果它存在于一个景点中，则可以满足。我们不考虑餐厅信息或住宿信息，而是修复每个信息餐厅价格为每人30英镑，住宿为每人100英镑。

D用于泛化评估的示例输入JSON和输出步骤

我们在这里包括了为看不见的约束类型生成JSON步骤的完整示例：

输入JSON查询{
“org”：“香港”，
“dest”：[“纽约市”，“曼谷”]，
“天”：5，
“visiting_city_number”：2，
“日期”：[“2023-12-22”，“2023-12-2023”，“2022年12月24日”，“2021年12月25日”，
“people_number”：3，
“local_contraint”：{
“飞行规则”：“不停站”，
“航空公司”：[“联合航空”，“阿联酋航空”]，
“吸引_类别”：[“花园”，“历史地标”]，
“运输”：“航班”
},
“预算”：5000
}
对应输出步骤#目的地城市#
#将城市设置为列表包括“纽约市”和“曼谷”
#2个目的地城市的环路
#初始化Z3解算器
#将“城市”变量设置为2个目的地城市的索引
#如果city__0_index和city__1_index不相同，则断言2个“city”变量等于城市索引
#出发日期#
#为城市之间的3个运输设置“departure_dates”变量
#断言第一次运输发生在第一天（第0天），最后一次运输发生于最后一天（第
4） ，第二次运输可能在其间的任何一天发生
#运输方式#
#为城市之间的3种运输设置运输方式（航班）变量
#断言城市之间的所有3种交通工具都是航班
#航班信息#
#运行FlightSearch以获取香港的航班信息，如始发地、城市_0和城市_1以及日期
#获取以香港为出发地和最终目的地的具体航班价格信息，具体城市变量，
3次运输的出发日期
#为3个运输设置“flight_index”变量
#如果乘坐航班，断言3个“flight_index”变量在有效范围内，断言航班指数为-1
如果不乘坐飞机
#根据航班指数变量计算3人3次运输的航班价格
#获取具体航班到达时间信息，以香港为出发地和最终目的地，具体城市，
3次运输的出发日期
#基于飞行指数变量计算3次运输的航班到达时间
#对于每个“flight_index”，获取特定的航班规则和航空公司信息，断言所有航班都存在“直达”航班，断言所有航班都存在“United”或“Emirates”
#景点信息#
#根据3次交通、5个总旅行日和出发时间，获取每天的到达和城市列表
日期变量
#运行AttractionSearch获取city_0和city_1的景点信息
#为5个（每天1个）景点设置“吸引_输入_城市”变量
#对于每个“吸引_城市_城市”变量，将其断言为基于当前城市或下一个城市
运输到达时间
#为5个（每天1个）景点设置“吸引指数”变量
#对于每个“吸引指数”，根据城市变量的吸引力获得特定的长度信息，
断言索引在有效范围内，并且同一城市的属性不重复
#为所需的每个类别设置“吸引类别”变量
#对于每个类别，遍历所有景点以检查是否满足
#餐厅信息#
#将餐厅价格设置为每人每餐30英镑，计算3人的餐厅总价格
5天
#住宿信息#
#将住宿价格设置为每人每晚100英镑，计算的总住宿价格3人住4晚
预算
#将预算限制变量设置为5000
#根据运输方式是否为航班，将3个运输价格相加
#将餐厅价格添加到已消费
#将住宿价格添加到支出中
#断言当前支出在预算范围内