想象你是一位要为百人婚宴掌勺的大厨。“做一整桌宴席”是一个令人窒息的大问题——食材、火候、上菜顺序、宾客口味，全都搅在一起。但真正的大厨不会对着空气发愁。他会先坐下，写一张菜单：四冷盘、八热菜、一汤一甜点。这张菜单，就是把“整场宴席”拆成了十几道“小菜”。更妙的是，他按依赖关系排好顺序：先吊高汤，再用高汤做酱汁；先卤肉，再借卤汁卤蛋。每完成一道菜，它就成了下一道菜的“跳板”。 这正是 Least-to-Most（由易到难分解）提示法的精髓。有一种教模型一步步推理的做法，就像一张“单菜食谱”——它教模型照着步骤做一道菜，但遇到整桌宴席就力不从心；而 Least-to-Most 把“写菜单”和“做菜”分成两个明确阶段：第一阶段让模型先把大问题拆成一串有顺序的子问题，第二阶段再逐个求解，并把前面得到的答案拼进上下文，帮助模型解下一道题。这套朴素的方法，在符号拼接、数学应用题、组合泛化等基准上带来了惊人的提升，也让“先规划再执行”成为大模型推理的标配思想。本篇文章，我们就从这张“菜单”说起。

岗位关联

理解 Least-to-Most 是掌握大模型结构化推理的钥匙：它教你如何用“先分解、再递进求解”的提示策略，把模型的能力从简单任务扩展到复杂任务——这是提示工程和推理模型设计中最高杠杆的技能之一。

目录
  1. 可视化演示
  2. 概念起源：从食谱到菜单
  3. 拆解策略：如何写好这张菜单
  4. 两阶段流程：后厨流水线
  5. 提升机制：为什么拆开反而更聪明
  6. 方法对比：几位大厨的不同流派
  7. 评测基准：如何品鉴这场盛宴
  8. 局限挑战：宴席也会有意外
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

动态演示Least-to-Most问的核心机制，通过源头/管道/节点/终端四种模式展示关键概念与交互流程。

本节配有交互动效（进入视口后自动加载，约 3KB）。

Least-to-Most问：Leas Least-to-Most的核 递归问题拆解的机制与策略 核心机制可视化 Least-to-Most问整体架构与关键组件

概念起源：从食谱到菜单

在给百人婚宴掌勺之前，大厨做的第一件事不是点火，而是写菜单。一张好的菜单，把“做一整桌宴席”这个让人头皮发麻的任务，变成“先做什么、再做什么、每道菜用什么原料”的清晰清单。这恰恰是 Least-to-Most（由易到难分解）提示法的第一性原理：任何复杂问题，都先拆解，再按序求解。

这项技术由 Google 团队在 2022 年提出，核心贡献是把“分解”从一种隐性的内部能力，变成一种显式的提示步骤。传统做法（包括思维链 CoT）是给模型看几个“问题—推理—答案”的示例，让模型自己在输出里模拟推理；而 Least-to-Most 直接要求模型在动手解题之前，先回答一个前置问题：“请把这个大问题拆成一串子问题”。于是，完整的流程被清晰地分成两个阶段：第一阶段是分解，模型输出一张有序的子问题清单；第二阶段是顺序求解，模型带着已经解出的答案，逐个击破。整个方法可以用一个简单的符号表达：

对宾客来说，吃到的是满满一桌菜；对厨房来说，工作是从一张菜单开始的。L2M 的“菜单”就是那张子问题清单——它把抽象的“难度”翻译成了具体的“顺序”，这是它与所有“一口气答完”类方法最本质的分水岭。

Q⇒[q1,q2,…,qn]\displaystyle Q \Rightarrow [q_1, q_2, \ldots, q_n]
这个公式读作“大问题 Q 被分解为有序的子问题序列 q₁ 到 qₙ”，它是理解 L2M 一切流程的地基。
  1. 原始问题 $Q$表示用户抛给模型的完整任务，例如“筹备一场百人婚宴”。它是一切拆解的起点，必须先被明确写出来。
    QQ
  2. 分解箭头 $\Rightarrow$代表由大模型执行的“分解”操作。它不是机械地切词，而是让模型通盘理解任务后，输出一张有序的“子问题清单”。
    ⇒\Rightarrow
  3. 子问题序列 $[q_1, q_2, \ldots, q_n]$方括号表示子问题按顺序排列，$q_1$ 到 $q_n$ 由易到难、首尾相接，全部求解后才能还原出整场“宴席”。
    [q1,q2,…,qn][q_1, q_2, \ldots, q_n]

拆解策略：如何写好这张菜单

菜单不是随便排的。大厨绝不会先上甜点再上热菜——他要先吊高汤，因为后厨所有酱汁都靠它；要先卤肉，再借卤汁卤蛋。子问题的排序，同样遵循依赖关系：必须先问“给了哪些条件”，才能问“条件之间怎么组合”。

拆解策略是 L2M 的灵魂。论文里常用的策略有三种：前向拆解（先确定第一步需要什么信息）、后向拆解（从目标倒推需要满足什么条件）、以及递归拆解（子问题仍太大时，继续细分）。不管哪种，核心原则都是让每个子问题只承担一个“小目标”，并且前后之间形成“上一题答案是下一题线索”的链条。

递归拆解让 L2M 不止适用于一层分解。当模型发现某个子问题依旧复杂时，可以对它再执行一次分解，得到更小的问题序列：

就像一份高级菜单至少分“前菜—主菜—甜点”三层，递归拆解把每一层再做细；但无论拆到多细，上菜的顺序始终是明确的——这就是依赖关系在提示词里的真实分量。

qi⇒[qi,1,qi,2,…,qi,mi]\displaystyle q_i \Rightarrow [q_{i,1}, q_{i,2}, \ldots, q_{i,m_i}]
这个公式表示“第 i 个子问题还能继续拆成 mᵢ 个更小的问题”，就像大菜单下的每一栏还有子菜单。
  1. 待拆子问题 $q_i$在第一次分解后，如果某个子问题仍然太大，说明这张“菜单”的一栏还能继续细分。
    qiq_i
  2. 递归分解箭头 $\Rightarrow$表示对子问题再次应用分解操作，每次递归都让问题规模更小，直到每个问题都“一口能吃下”。
    ⇒\Rightarrow
  3. 更小的问题序列 $[q_{i,1}, q_{i,2}, \ldots, q_{i,m_i}]$下标 $i,1$ 表示“第 $i$ 个子问题下的第 1 个小问题”，$m_i$ 表示这个子问题被拆成了 $m_i$ 份。
    [qi,1,qi,2,…,qi,mi][q_{i,1}, q_{i,2}, \ldots, q_{i,m_i}]

两阶段流程：后厨流水线

后厨的流水线是严格串行的：炖汤的时候不能同时去炒需要急火的菜，因为灶台有限，而每一道菜出锅，又为下一道菜腾出了锅和调料。L2M 的“两阶段流程”，就是把这条流水线搬进了提示词。

阶段一的提示词大约长这样：“请把下面问题拆解成若干个子问题，并按求解顺序列出。”模型输出的是纯问题清单，不包含答案。阶段二则把原问题、子问题清单、以及已经得到的问答对全部拼接起来，要求模型只回答当前这个子问题；答完一个，就把这组问答追加进上下文，继续下一个。用数学语言描述，第 $i$ 个子问题的求解可以被写成一次“条件生成”：

这道菜出锅后不会端上桌，而是先留在备餐台——它的汤汁要浇到下一道菜上。后厨的每一份“上一步的产物”，都是“下一步的调料”；而原问题这张“总菜单”，始终贴在墙上，提醒所有步骤不要跑偏。

ai=LLM(qi∣Q,q1,a1,…,qi−1,ai−1)\displaystyle a_i = \mathrm{LLM}\left(q_i \mid Q, q_1, a_1, \ldots, q_{i-1}, a_{i-1}\right)
这个公式是说：第 i 个子问题的答案，是在“原问题 + 之前所有问答”的共同条件下生成的——每一步都站在前一步的肩膀上。
  1. 当前答案 $a_i$表示第 $i$ 个子问题的求解结果，它会被保存下来，作为后一道“菜”的原料。
    aia_i
  2. 条件竖线 $\mid$读作“在……的条件下”。它表示模型生成答案时，不是凭空发挥，而是看到竖线右侧的全部内容后才开口。
    ∣\mid
  3. 历史问答拼接 $Q, q_1, a_1, \ldots, q_{i-1}, a_{i-1}$原始问题始终在场，配合此前每一组“子问题—答案”，构成递进求解的完整上下文。
    Q,q1,a1,…,qi−1,ai−1Q, q_1, a_1, \ldots, q_{i-1}, a_{i-1}

提升机制：为什么拆开反而更聪明

为什么拆开做反而更聪明？想象后厨同时开十个灶眼，每个厨师都要同时盯着十口锅——注意力严重稀释。而 Least-to-Most 让每个厨师一次只盯一口锅，火候自然拿捏得准。

从概率角度看，L2M 之所以有效，是因为它把“一个很难的条件概率”拆成了“一串很容易的条件概率”。原问题直接求解，等价于让模型在又长又复杂的上下文里一次推理到位；而拆解后，每一步只需要关注一个小问题加一截短历史，单步错误率显著下降。用条件概率的链式法则可以看得更清楚：

更重要的是，错误被隔离在单口锅里：某道菜做砸了，最多重新做这一道，不必推翻整桌宴席。每一步的答案又被下一道菜复用，这就是“记忆复用”与“错误隔离”给推理带来的双重红利。

P(a1,a2,…,an∣Q)=∏i=1nP(ai∣qi,a<i)\displaystyle P(a_1, a_2, \ldots, a_n \mid Q) = \prod_{i=1}^{n} P\left(a_i \mid q_i, a_{<i}\right)
这个公式把“整串答案全部正确”的概率，拆成每一步条件概率的连乘——每一步都在更短、更聚焦的条件下进行，整体才更可靠。
  1. 联合概率 $P(a_1, a_2, \ldots, a_n \mid Q)$衡量“在原问题下，整串答案全部正确”的概率，这正是最终要提升的目标。
    P(a1,a2,…,an∣Q)P(a_1, a_2, \ldots, a_n \mid Q)
  2. 连乘号 $\prod_{i=1}^{n}$把每一步的成功概率乘在一起，说明整体成功依赖每一步都成功。
    ∏i=1n\prod_{i=1}^{n}
  3. 单步条件概率 $P(a_i \mid q_i, a_{<i})$第 $i$ 步只在一个小问题、一小段历史上做判断，条件变短，单步更容易答对。
    P(ai∣qi,a<i)P\left(a_i \mid q_i, a_{<i}\right)

方法对比：几位大厨的不同流派

同样一场宴席，不同流派的大厨风格迥异：有的照着一本食谱闷头做（标准提示），有的按一张长食谱一路做到底（思维链 CoT），有的让几位副厨各做一版请宾客投票（Self-Consistency），还有的每道菜都试几种做法再择优（Tree-of-Thought）。

标准提示让模型直接输出答案，适合简单题；CoT 让模型先生成一条推理链再给答案，适合中等难度；L2M 在此基础上加了“显式菜单”，适合结构复杂的大问题；Self-Consistency 不去改变推理路径，而是对同一条路径采样 $K$ 次再多数投票；Tree-of-Thought 则把每一步的多个候选都展开成一棵树，用搜索和回溯代替单链推进。这些方法并不互斥——L2M 的每个子问题都可以配合 CoT 解释，也可以配合 Self-Consistency 投票，甚至可以把 Tree-of-Thought 的搜索回溯嵌入到单步求解中。Self-Consistency 的投票机制可以写成：

大厨的流派可以混搭：先写菜单（L2M 分解），每道菜请三位副厨各做一遍（SC 采样），大家投票定口味，再对不满意的菜回到备料阶段重新尝试（ToT 回溯）。推理模型的多方法融合，本质上就是后厨的“取长补短”。

A^=arg⁡max⁡a∈A∑k=1K1[A(k)=a]\displaystyle \hat{A} = \arg\max_{a \in \mathcal{A}} \sum_{k=1}^{K} \mathbb{1}\left[A^{(k)} = a\right]
这个公式说的是：同一问题采样 K 次，数一数哪个答案被选中次数最多，就把票数最高的那个作为最终答案。
  1. 第 $k$ 次采样答案 $A^{(k)}$同一个子问题让模型采样 $K$ 次，得到 $K$ 个候选答案，相当于请 $K$ 位品菜师分别打分。
    A(k)A^{(k)}
  2. 指示函数 $\mathbb{1}[\cdot]$当方括号里的等式成立时取 1，否则取 0，用来统计“这个答案被选中了几次”。
    1[A(k)=a]\mathbb{1}\left[A^{(k)} = a\right]
  3. 求和与最大值 $\sum$ 与 $\arg\max$先对 $K$ 次采样求和得到每个候选答案的票数，再取出票数最高的答案作为最终输出。
    arg⁡max⁡a∈A∑k=1K\arg\max_{a \in \mathcal{A}} \sum_{k=1}^{K}

评测基准：如何品鉴这场盛宴

判断一位大厨是否真有手艺，不能只听他讲理念，要上菜品鉴。对推理模型而言，“品鉴”就是一套套标准化的评测基准。

L2M 论文主要报告了三类基准：一是符号推理任务 Last Letter Concatenation——把一句话末尾几个单词的首字母拼接起来，问题简单但链条长，直接求解极易出错；二是组合语义解析基准 SCAN——模型要学会把“跳跃两次”这类指令组合成新指令，考的是组合泛化；三是数学应用题 GSM8K——小学到初中水平的文字题，考的是多步计算与语义理解。评测口径通常用准确率，即答对的样本占全部样本的比例：

结果令人印象深刻：在 SCAN 上，标准提示的准确率只有约 16%，思维链也仅能覆盖训练分布内的样本，而 L2M 把组合泛化的准确率推到了接近 100%。这相当于一位只做过家常菜的大厨，突然被证明能驾驭满汉全席——而秘诀不是换了食材，而是学会了先写菜单。

Acc=1N∑j=1N1[A^j=Aj]\displaystyle \text{Acc} = \frac{1}{N} \sum_{j=1}^{N} \mathbb{1}\left[\hat{A}_j = A_j\right]
这是最朴素的“得分率”公式：答对一题记一分，除以总题数就是准确率。
  1. 样本总数 $N$测试集里一共有 $N$ 道题，相当于宴席上总共要品鉴 $N$ 道菜。
    NN
  2. 正确计数 $\mathbb{1}[\hat{A}_j = A_j]$第 $j$ 题预测答案与标准答案一致时记 1，累计所有答对的题目数量。
    1[A^j=Aj]\mathbb{1}\left[\hat{A}_j = A_j\right]
  3. 平均 $\frac{1}{N}\sum$把答对总数除以总题数，得到 0 到 1 之间的准确率，越接近 1 说明“大厨”越靠谱。
    1N∑j=1N\frac{1}{N} \sum_{j=1}^{N}

局限挑战：宴席也会有意外

再老的江湖也有失手的时候：菜单写错了、某道菜的食材不新鲜、传菜顺序被打乱——宴席照样会砸。L2M 的局限，同样藏在它的“链式”结构里。

首先，分解质量完全依赖模型自身的能力，如果模型连“这个问题的第一步该问什么”都想不清楚，拆出来的子问题清单反而会误导后续求解；其次，子问题答案会被拼进后续上下文，任何一步出错都会向后传播，而且链条越长，累积风险越大；最后，显式分解和逐题求解会消耗大量 token，在长问题上开销成倍增长。误差传播可以做一个简单的数学刻画：

一桌十道菜的宴席，如果每道菜有 95% 的成功率，整桌全对的概率只剩约 60%。这不是说 L2M 不可用，而是提醒我们：菜单要写得足够好，每道菜要做得足够稳，且不要为凑数而无限加菜——好的分解，贵精不贵多。

Pfinal=∏i=1npi≈pn\displaystyle P_{\text{final}} = \prod_{i=1}^{n} p_i \approx p^n
这个公式揭示了链式推理的残酷一面：如果每一步的成功率都是 p，n 步之后总成功率按指数衰减。
  1. 单步成功率 $p_i$第 $i$ 个子问题被正确求解的概率。
    pip_i
  2. 链式连乘 $\prod_{i=1}^{n} p_i$最终成功需要每一步都不出错，整体概率等于各步概率的乘积。
    ∏i=1npi\prod_{i=1}^{n} p_i
  3. 指数近似 $p^n$当各步成功率相近（都约为 $p$）时，链条越长，最终成功率按指数衰减——这就是误差沿链传播的数学真相。
    pnp^n

AI 应用场景

智能客服工单分诊

阶段：问题拆解与按序推理

解决的问题：传统客服机器人面对“订单没到、运费出错、发票缺失”缠在一起的复杂投诉，直接生成答案往往顾此失彼。用 L2M 先把投诉拆成“确认订单信息→定位物流环节→排查异常原因→给出处理方案”几个子问题，再带着前置结论逐题回答，答复的完整度和准确率显著提升，就像大厨先把宴席拆成一道道菜再逐个烹饪。

具体案例：某电商智能客服接入 L2M 提示模板，用户投诉“昨天买的充电宝充不进电”，系统先拆分出“订单是否在质保期？→常见故障模式有哪些？→适用处理方案是什么？”，逐个子问题求解后拼装成最终答复，工单一次解决率提升约 20%。

数学解题辅导 Agent

阶段：推理规划与可解释生成

解决的问题：直接给答案教不会学生，而 L2M 让 AI 辅导 Agent 按“审题→提取已知条件→列出关系式→求解→检验”的顺序教学，每一步都可解释、可纠偏。学生答对一步才进入下一步，学习体验从“被喂答案”变成“被引导思考”。

具体案例：某教育大模型产品用 L2M 处理“求二次函数最值”类题目，先把问题拆成“开口方向如何判断？→对称轴在哪里？→定义域限制是什么？→最值在哪一点取得？”，每题输出提示加追问，学生按步骤作答后系统再汇总评价，学习完成率明显提升。

代码缺陷排查助手

阶段：根因分析与修复生成

解决的问题：复杂的 bug 报错信息长、堆栈深，直接让模型修复容易乱改代码。L2M 将排查拆成“复现路径→定位模块→检查变量状态→推断根因→制定修复方案”，逐步收敛问题范围，避免模型在长上下文里迷失。

具体案例：研发辅助工具对一条“内存泄漏”报告执行 L2M 流程，先列出子问题清单，再逐一求解，最终定位到连接池未释放的根因，并生成修复补丁，修复通过率比直接提示提升约三成。

Python 演示

python55 行
import re  def decompose(problem, target):    """阶段一：把大问题拆成有序的子问题清单"""    words = re.findall(r"[A-Za-z]+", problem)    n = len(words)    start = n - target    return [        "取出第" + str(j + 1) + "个单词的最后一个字母并拼接到已有答案后"        for j in range(start, n)    ]  class MockLLM:    """模拟语言模型：从提示中解析当前子问题并返回答案"""     def __init__(self):        self.words = []        self.gc_count = 0     def load(self, word_list):        self.words = word_list     def complete(self, prompt):        self.gc_count += 1        matches = re.findall(r"第(\d+)个单词", prompt)        if not matches:            return "?"        index = int(matches[-1]) - 1        return self.words[index][-1]  def least_to_most(problem, target, llm):    """阶段二：按序求解，并把之前的问答拼进上下文"""    subs = decompose(problem, target)    results = []    for q in subs:        context = "原问题：" + problem + "\n"        for prev_q, prev_a in results:            context += "已解决：" + prev_q + " 答案：" + prev_a + "\n"        context += "当前子问题：" + q + "\n"        answer = llm.complete(context)        results.append((q, answer))    return "".join(ans for _, ans in results)  if __name__ == "__main__":    problem = "apple banana cherry dog elephant"    words = re.findall(r"[A-Za-z]+", problem)    llm = MockLLM()    llm.load(words)    answer = least_to_most(problem, 3, llm)    print("final:", answer)    print("calls:", llm.gc_count)
目的：用最小可运行的模拟 LLM 演示 Least-to-Most 的两阶段流程——先拆解出子问题清单，再带着历史问答逐个求解，最终拼接出“最后三个单词末尾字母”的答案。
  1. def decompose(problem, target):阶段一的入口，把原问题变成子问题清单，对应“大厨写菜单”。
  2. "取出第" + str(j + 1) + "个单词的最后一个字母并拼接到已有答案后"每个子问题都显式提到“拼接已有答案”，这正是 L2M 顺序依赖的关键设计。
  3. def least_to_most(problem, target, llm):阶段二的编排器，负责按序求解并管理上下文。
  4. context += "已解决：" + prev_q + " 答案：" + prev_a + "\n"把前面所有问答拼进提示，模拟“每道菜成为下一道菜的调料”。
  5. answer = llm.complete(context)模型只回答当前这一个子问题，单步聚焦。
  6. matches[-1]从提示中取最后一次出现的子问题编号，模拟模型关注“最近的指令”，绕开历史问答的干扰。
  7. results.append((q, answer))保存当前问答对，供后续子问题复用。
  8. llm.load(words)把单词表装进模拟模型，相当于预训练阶段习得的“世界知识”。

常见误区

误区我觉得 Least-to-Most 就是把提示词写长一点，多写几个“请一步一步思考”就差不多了，本质上和思维链一样。

正解多写“一步一步”只是语言层面变长，模型可能照着学，但仍是在“一口闷”地做整道题；L2M 是结构层面改变——它先单独输出一份子问题清单，再带着前序问答逐个求解，每个子问题都获得独立且精简的条件。就像把菜谱写厚并不能做出宴席，必须先有菜单（分解），再按菜单逐道上菜（求解）。

为何常见：因为两者都表现为“更长的提示”，初学者容易只看到长度，看不到两阶段的组织方式。

误区既然拆开有效，那我就把问题拆成二十个小问题，拆得越细模型越不容易出错。

正解拆解并非越细越好。每多一个子问题，就多一次出错机会、多一段上下文、多花一次模型调用；更重要的是，过细的子问题可能脱离原题的全局约束。正确做法是顺着依赖关系拆：先拿关键信息，再逐步推导，每一步解决一个不可再分的小目标。好比切菜不是越碎越好，切到适合烹调的尺寸就够了。

为何常见：“越小越简单”的直觉是对的，但忽略了链条上的误差累积与开销成本。

误区Least-to-Most 里的“分解”很像分治算法，所以各个子问题应该互相独立，可以并行处理。

正解L2M 是串行递进：第 i 个子问题的提示里明确包含前 i-1 个问答，后一步依赖前一步的答案。这和分治（Divide and Conquer）的并行子任务有本质区别。只有在某些没有依赖的环节，才能配合 Self-Consistency 做并行采样。菜单可以同时打印，但上菜必须按顺序。

为何常见：“分解”一词容易让人联想到 MapReduce 式的并行分治，忽略了提示中的顺序拼接。

误区思维链是思维链，Least-to-Most 是另一种独立方法，两者没有交集。

正解L2M 实际上是思维链的“超集式扩展”：在求解每个子问题时，模型通常仍要输出一小段推理（本质上就是微缩版 CoT），而 L2M 额外增加了“显式分解”这一阶段。论文里也常把 CoT 作为基线来对比；两者是“单步推理链”与“多阶段规划加推理链”的关系。好比菜谱是每道菜的做法，菜单则是整场宴席的统筹——两者协同而非对立。

为何常见：论文标题把它们写成两个独立名词，读者容易只记名字、不查关系。

面试题

Q1. Least-to-Most 提示法的核心思想是？

单选题 · easy

  • A.先拆成有序子问题再逐个求解← 正确答案
  • B.让模型一次性生成完整答案
  • C.用更大的训练数据提升理解
  • D.对输出做采样并选择最可能

答案：A。L2M 的两阶段核心就是“先分解、再按序求解”；B 是标准提示的做法，C 是训练侧操作，D 更像是 Self-Consistency 的思路。好比大厨先写菜单再逐道上菜，而不是一锅乱炖。

Q2. 相比思维链 CoT，L2M 的关键改进是？

单选题 · easy

  • A.把问题分解步骤显式化← 正确答案
  • B.增加模型的参数量
  • C.改用更大的训练语料库
  • D.完全取消示例提示

答案：A。CoT 让模型在一条提示里隐含地做推理，L2M 把分解变成独立的、可见的提示阶段；B 和 C 改变的是模型与数据，不是提示结构；D 错误，L2M 仍可搭配示例。

Q3. Self-Consistency 方法的核心机制是？

单选题 · mid

  • A.多次采样并对答案投票← 正确答案
  • B.单次生成最优的推理链
  • C.对输入做同义改写增强
  • D.使用更强的预训练权重

答案：A。Self-Consistency 的本质是采样多条推理路径再多数投票；B 正是它要解决的问题，C 是数据增强，D 是模型规模问题，都与投票机制无关。

Q4. 求解第 i 个子问题时，提示应包含？

单选题 · mid

  • A.前面所有子问题的问答← 正确答案
  • B.仅当前这一个子问题
  • C.随机抽取的训练示例
  • D.模型的置信度分数

答案：A。L2M 顺序求解时，把前面所有问答拼进上下文作为条件，让每个新答案“站在前一步肩膀上”；B 缺少历史就无法递进，C 不是 L2M 的固定要求，D 是解码细节而非提示内容。

Q5. SCAN 基准主要用来测模型的？

单选题 · mid

  • A.组合泛化推理能力← 正确答案
  • B.情感分类判别能力
  • C.图像分割理解能力
  • D.语音识别转写能力

答案：A。SCAN 是组合语义解析基准，专测模型能否把学过的小指令组合成新指令；B、C、D 分别属于文本分类、视觉、语音领域，与 SCAN 无关。

Q6. 关于 L2M 误差传播的正确说法是？

单选题 · hard

  • A.前一步错误会沿链条放大← 正确答案
  • B.误差只影响当前子问题
  • C.分解阶段一般不会出错
  • D.最终答案与前面无关

答案：A。因为子问题答案会被拼进后续上下文，前面错了后面会跟着错，误差沿链放大，正如 pⁿ 指数衰减；B 忽略了上下文拼接，C 把分解想得过于完美，D 违背 L2M 的基本设计。

Q7. 下列哪项不是 L2M 提升推理的原因？

单选题 · hard

  • A.增加模型的参数量← 正确答案
  • B.降低单步推理的复杂度
  • C.缩小每步的注意力范围
  • D.隔离错误并继续传递

答案：A。L2M 不改变模型参数，提升来自提示结构本身；B、C、D 都是 L2M 有效的原因——单步更简单、注意力更聚焦、错误被隔离。增加参数量属于训练侧手段。

Q8. 哪些方法可以和 L2M 组合使用？

多选题 · mid

  • A.自洽性投票机制← 正确答案
  • B.思维树搜索回溯← 正确答案
  • C.随机梯度下降
  • D.全精度微调

答案：AB。L2M 可与 Self-Consistency 结合（每个子问题多采样投票），也可用 Tree-of-Thought 的搜索回溯改进单步求解；C 和 D 是训练方法，不属于推理期的提示组合。

Q9. 下列属于 L2M 局限性的是？

多选题 · hard

  • A.分解质量依赖模型← 正确答案
  • B.错误沿链条传播← 正确答案
  • C.增加推理计算开销← 正确答案
  • D.完全消除幻觉问题

答案：ABC。L2M 的三大局限正是分解质量依赖模型、误差沿链传播、token 开销成倍增长；D 错误——幻觉问题并不能被任何提示方法“完全消除”。

Q10. 下列属于 L2M 拆解策略的有？

多选题 · easy

  • A.递归拆分大问题← 正确答案
  • B.按依赖排序子问题← 正确答案
  • C.从输出反推步骤← 正确答案
  • D.随机打乱子问题顺序

答案：ABC。递归拆解、依赖排序、后向反推都是论文中出现的拆解思路；D 随机打乱会破坏依赖顺序，违背 L2M“由易到难、层层递进”的初衷。