如果你在陌生的城市问路，遇到两种回答：一种只说“到了”，另一种说“出地铁口右转，直行二百米，看到红绿灯左转，再走五十米就是”——你会更信任哪一种？后者把“怎么走”拆成了一段段可验证的小步骤，这就是思维链（Chain-of-Thought，简称 CoT）的日常模样。大语言模型表面上是“问一句答一句”，但很多时候它也需要“思考”。思维链要做的，就是明确要求它把思考过程一步步摊开，而不是直接甩出一个最终答案。传统的标准提示词像是只告诉目的地、不给路线的向导；思维链提示词则像手机导航里的逐路段播报。本文会用这个“问路导航”的比喻，带你理解思维链的原理、两种常用触发方式、在数学和逻辑题里的效果，以及如何设计出好用的思维链提示词。

岗位关联

对 AI 从业者来说，思维链是让大模型处理复杂推理任务的“开罐器”：掌握它，你才能用简单的提示词撬动模型真正的推理能力，提升 AI 应用的可靠程度与专业度。

目录
  1. 可视化演示
  2. CoT原理
  3. 标准Prompt对比
  4. Zero-shot CoT
  5. Few-shot CoT
  6. 数学推理应用
  7. 逻辑推理应用
  8. 实战设计要点
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

展示CoT逐步推理原理、Zero-shot与Few-shot实现对比、CoT vs标准提示性能差异及CoT到自洽思维树方法演进，步进式切换深入理解思维链推理核心。

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

CoT核心思想：逐步推理显式化中间步骤 让模型在给出答案前先展示中间推理步骤 将隐含推理过程显式化，显著提升复杂推理准确率 Problem → Step1 → Step2 → ... → Answer 像人类解题一样分解问题。

CoT原理

如果把大模型比作一个不太认识路的出租车司机，标准提问方式是直接问：“火车站怎么走？”司机说：“到了。”你拿着这个答案根本不敢下车。思维链则要求司机把沿途经过的每一个路口都报出来：“先右转，再直行，看到大钟后左转。”这些“路口”就是模型的中间思考步骤。

思维链的核心理念很简单：不仅让模型输出答案，还要它先输出一段从问题到答案的中间推理。这段推理通常由若干个小步骤组成，就像导航路线由多个转弯路段组成。每一步都以上一步的结果作为输入，最终指向答案。对复杂推理任务来说，把步骤写出来，比直接猜一个答案可靠得多。

模型生成思维链时，本质上是在学习“如何一步步到达答案”。虽然大模型的内部机制仍然是概率预测，但显式的步骤让它更容易维持长程依赖，也让我们能检查它到底在哪里走错了路。思维链可以表示成一条清晰的链条：

回到导航的比喻：如果你知道司机在哪个路口转错了，就能及时纠正；思维链的价值正是把“路口”暴露出来。对 AI 从业者来说，这意味着我们不再只能对着一个最终答案干瞪眼，而是可以定位、检查、修正模型的推理路径。

x→s1→s2→⋯→sn→y\displaystyle x \rightarrow s_1 \rightarrow s_2 \rightarrow \cdots \rightarrow s_n \rightarrow y
这个公式想说明：问题 x 不是直接变成答案 y，而是先经过若干个中间步骤 s，再由最后一步得到结论。
  1. 输入问题 \(x\)用户给出的题目或指令，是思维链的起点。
    xx
  2. 第一个中间步骤 \(s_1\)模型把问题拆成第一个可验证的小结论。
    x→s1x \rightarrow s_1
  3. 多步串联 \(s_2,\dots,s_n\)后面的步骤依赖前面的结果，像导航的下一个路口。
    s1→s2→⋯→sns_1 \rightarrow s_2 \rightarrow \cdots \rightarrow s_n
  4. 最终答案 \(y\)链条走完后的输出。
    sn→ys_n \rightarrow y

标准Prompt对比

“到了”式回答对应的就是标准 Prompt（Standard Prompting）。它给模型一个问题和“答案：”的提示，期待模型直接给出最终结果。这种模式适合“3 加 5 等于几”这样的简单任务，但面对“先算括号、再乘系数、最后减优惠”的多步问题时，就很容易跳步出错。

思维链提示词和标准 Prompt 最大的差别，是它把“中间推理”显式地写进输出预算里。你可以要求模型“先解释，再给答案”，也可以给它几个带推理过程的示例。无论是哪种方式，核心都是在引导模型走完一整条高概率的路线，而不是抄近路直达终点。

从概率角度理解，最终答案 \(y\) 的正确率可以看作所有可能思维链的加权结果。标准 Prompt 隐式地“猜”一条路，思维链显式地“走”一条路：

两种导航风格各有适用场景。如果目的地就在眼前，标准 Prompt 更省字；如果路线绕来绕去，思维链就是防止走错路的安全带。AI 应用开发者应该根据任务复杂度，决定到底用“直达答案”还是“逐段导航”。

p(y∣x)=∑sp(y∣x,s) p(s∣x)\displaystyle p(y \mid x) = \sum_{\mathbf{s}} p(y \mid x,\mathbf{s})\, p(\mathbf{s} \mid x)
简单说：答案靠不靠谱，取决于有没有一条合理的推理链能把它带出来。思维链就是把这条链明确写出来，而不是让它淹没在模型的隐式计算里。
  1. 答案 \(y\)模型最终要输出的文本。
    yy
  2. 中间步骤序列 \(\mathbf{s}\)由很多小步组成的一条推理链。
    s=(s1,s2,…,sn)\mathbf{s} = (s_1, s_2, \dots, s_n)
  3. 给定问题的概率 \(p(\mathbf{s}\mid x)\)在已知问题 \(x\) 时，模型选择这条思维链的概率。
    p(s∣x)p(\mathbf{s}\mid x)
  4. 边缘化求和 \(\sum_{\mathbf{s}}\)把所有可能思维链的答案概率累加起来，得到最终答案的整体概率。
    ∑sp(y∣x,s) p(s∣x)\sum_{\mathbf{s}} p(y \mid x,\mathbf{s})\, p(\mathbf{s} \mid x)

Zero-shot CoT

有时候，我们不想准备一大堆示例，只想快速让模型“动动脑子”。这就像临时拦下一辆出租车，对司机说：“师傅，麻烦您每到一个路口就告诉我一声。”司机不需要你提前画好地图，也能把思考过程说出来。

Zero-shot CoT 就是这么一种轻量技巧：在问题后面加一句触发语，最常见的是“让我们一步一步地想”。它不给模型任何示例，却能让模型生成一段推理过程，再给出答案。研究表明，这种简单拼接在数学应用题、逻辑推断等任务上都能带来显著提升。

它的原理是激活模型在训练中学到的“展开思考”模式。只要问题以“答案：”收尾，模型倾向于直接猜；但一旦出现“让我们一步一步地想”，模型就倾向于先组织中间步骤。可以把这个提示词结构写成：

Zero-shot CoT 的优点是便捷高效，不需要整理示例。但它的输出格式比较自由，偶尔会啰嗦或跑偏。对于快速原型验证，它是最好的起点，正如你临时叫车时的一句“每到一个路口告诉我一声”。

Promptzero=x⊕ttrigger\displaystyle \text{Prompt}_{\text{zero}} = x \oplus t_{\text{trigger}}
这里 \(t_{\text{trigger}}\) 就是一句触发语，比如“让我们一步一步地想”。它相当于告诉司机：“不要直接说到站，请把每个路口报给我。”
  1. 原始问题 \(x\)用户输入的自然语言题目。
    xx
  2. 拼接运算符 \(\oplus\)把两段文本前后相连，构成完整提示词。
    x⊕ttriggerx \oplus t_{\text{trigger}}
  3. 触发短句 \(t_{\text{trigger}}\)例如“让我们一步一步地想”，它告诉模型先展开推理再给答案。
    ttriggert_{\text{trigger}}
  4. CoT 提示词 \(\text{Prompt}_{\text{zero}}\)拼接后的完整输入。
    Promptzero=x⊕ttrigger\text{Prompt}_{\text{zero}} = x \oplus t_{\text{trigger}}

Few-shot CoT

更好的导航方式是：你先自己开车走一遍，把沿途路口录下来给司机看。Few-shot CoT 做的就是这件事——在提示词里放几个“问题 + 推理过程 + 答案”的完整示例，让模型照着同样的格式思考。

这些示例不是随便凑数的，而是模型模仿的路线样本。每个示例都要有清楚的问题、合理的中间步骤、标准的答案格式。模型看到这些示例后，会模仿其中的推理风格和输出结构，从而在遇到新问题时也“一步一步地走”。

Few-shot CoT 的提示词结构可以写成一组示例的集合，再接上新的问题：

Few-shot CoT 比 Zero-shot 更稳定，因为示例约束了输出格式。但示例质量比数量更重要：一个跳步的坏示例，可能比没有示例更糟糕。就像给司机看一张错误地图，他反而会模仿错误走法。

Dk={(qi,ri,ai)}i=1k,Promptfew=Dk⊕qnew\displaystyle D_k = \{(q_i, r_i, a_i)\}_{i=1}^{k},\qquad \text{Prompt}_{\text{few}} = D_k \oplus q_{\text{new}}
意思是：先给模型 k 组“问题-推理-答案”的范例，再把真正要回答的问题接在后面，让模型按范例的格式继续写。
  1. 示例问题 \(q_i\)第 \(i\) 个示例的题干。
    qiq_i
  2. 示例推理 \(r_i\)模型希望模仿的中间推理过程。
    rir_i
  3. 示例答案 \(a_i\)完整推理后的最终结果。
    aia_i
  4. k 条示例的集合 \(D_k\)把多个三元组放进提示词，为新问题提供参照。
    Dk={(qi,ri,ai)}i=1kD_k = \{(q_i, r_i, a_i)\}_{i=1}^{k}
  5. 新问题拼接在示例后接上待回答的问题，让模型按同样格式输出。
    Promptfew=Dk⊕qnew\text{Prompt}_{\text{few}} = D_k \oplus q_{\text{new}}

数学推理应用

数学题是最容易“一步错，步步错”的任务。想象你要去一个商场，票价是每本书 12 元，买 4 本，再减 5 元优惠。如果导航只说“终点到了”，你根本不知道 43 元这个答案是怎么算出来的；如果它把“先算总价 48，再减 5”报出来，你就能立刻检查每一步。

思维链在数学推理中的价值，就是把多步计算拆成可检查的小步。跳步是数学错误的重要来源，而 CoT 逼着模型把每一步都落地。以表达式 \(((5+3)\times 4)-2\) 为例，模型可以按顺序写出：

数学推理应用最能体现思维链的“可验算”优势。模型把草稿纸摆在你面前，而不是只报一个结果。对计算密集型应用来说，这是降低错误率最直接的方式。

s1=a+b,s2=s1×c,s3=s2−d,y=s3\displaystyle s_1=a+b,\quad s_2=s_1\times c,\quad s_3=s_2-d,\quad y=s_3
在这个式子里，\(a=5, b=3, c=4, d=2\)。每一步都依赖上一步的结果，任何一步错了都能被单独发现。
  1. 第一步 \(s_1=a+b\)先算括号内的小计，对应“先走到第一个路口”。
    s1=a+bs_1=a+b
  2. 第二步 \(s_2=s_1\times c\)把小计乘上倍数，后一步使用前一步结果。
    s2=s1×cs_2=s_1\times c
  3. 第三步 \(s_3=s_2-d\)最后减去优惠，得到最终数值。
    s3=s2−ds_3=s_2-d
  4. 最终答案 \(y=s_3\)链条终点就是答案。
    y=s3y=s_3

逻辑推理应用

逻辑题像一座复杂的立交桥：每个路口都有“如果……那么……”的规则，走错一个匝道，结论就会完全跑偏。思维链在这里扮演的角色，是一个耐心读路牌的导航员，把条件关系一条条理清楚。

逻辑推理任务通常包含多重条件和隐含因果。模型如果直接跳结论，很容易被表面措辞误导。CoT 会先把条件列出来，再一步步推出中间的判断，最后才给出结论。经典的“假言推理”就是最典型的思维链：

逻辑推理中的 CoT，本质上是在帮助模型“不跳步”。每一步都对应一个逻辑依据，就像导航在每一个匝道口都提前提示。结果不仅更准确，而且更容易向用户解释：我们不是只相信答案，而是相信推导过程。

A→B,A∴B\displaystyle \frac{A \rightarrow B,\quad A}{\therefore B}
意思是：如果 A 成立就能推出 B，而现在确实有 A，所以可以得出结论 B。思维链会把这条因果链一步一步写清楚。
  1. 前提规则 \(A \rightarrow B\)如果 A 成立，就能推出 B。
    A→BA \rightarrow B
  2. 条件确认 \(A\)题目中已给出 A 成立。
    AA
  3. 推导结论 \(B\)根据规则推出 B。
    BB
  4. 推导符号 \(\therefore\)表示“所以”。
    ∴B\therefore B

实战设计要点

设计思维链提示词，就像设计一条导航路线：路口太密，司机会被吵晕；路口太少，司机又容易错过转弯。好的思维链提示词，应该有适中的步骤粒度、清晰的输出结构，以及合理的长度限制。

在实际开发中，你可以在提示词里明确要求“每一步不超过一句话”“先写推理，再写答案”。也可以准备几个高质量示例，统一推理格式。还要注意上下文窗口的预算，因为每个中间步骤都会消耗 token。步骤过长会浪费资源，也可能累积更多错误。可以用一个简单的预算公式来提醒自己：

实战中还要警惕“幻觉”：模型可能一本正经地编造中间步骤。因此，凡是能用程序验证的步骤，尽量交给代码校验；凡是不能验证的推理，要在提示词中要求模型克制，不要脑补额外条件。思维链是工具，不是圣旨——它把思考过程摊开，最终判断仍然要由开发者来把关。

NCoT=Nquestion+∑j=1nNj+Nanswer≤Nmax⁡\displaystyle N_{\text{CoT}} = N_{\text{question}} + \sum_{j=1}^{n} N_j + N_{\text{answer}} \le N_{\max}
意思是：思维链提示词的总长度，等于问题、所有中间步骤和答案占用的 token 之和，不能超过上下文窗口上限。
  1. 问题占用的 Token 数 \(N_{\text{question}}\)输入提示词的固定开销。
    NquestionN_{\text{question}}
  2. 第 \(j\) 步的 Token 数 \(N_j\)每个中间步骤都会消耗输出额度。
    ∑j=1nNj\sum_{j=1}^{n} N_j
  3. 答案 Token 数 \(N_{\text{answer}}\)最终回复的长度。
    NanswerN_{\text{answer}}
  4. 总长度上限 \(N_{\max}\)模型上下文窗口或应用预算约束。
    Nmax⁡N_{\max}

AI 应用场景

智能客服：处理多条件退款

阶段：提示词工程 / 应用开发

解决的问题：传统关键词匹配客服只会机械回复“稍等”，遇到“周五买的、还没到、要求补发”这种多条件问题，很难给出准确结论。思维链可以把判断过程拆成“验证订单是否成立 → 检查发货时间 → 判断是否超时 → 给出处理建议”，让客服系统按固定步骤推理。

具体案例：用户在电商 App 里提问：“我周五买的东西，今天周四还没到，能不能申请补发？”客服机器人先用 CoT 提示词分步推理：订单状态正常、仍在承诺时效内、暂时不能补发但可催派，最终给出“已催派，请再等一天”的答复。

数据分析助手：生成多表 SQL

阶段：推理上下文设计 / 代码生成

解决的问题：直接让模型写 SQL，它可能忽略 join 条件或时间范围，导致统计结果错误。思维链可以要求模型先列出涉及的表、筛选条件、分组字段，再编写 SQL 语句，把每一步推理都写在代码之前。

具体案例：业务人员问“华东区 Q2 销售额比 Q1 高多少？”数据分析助手先用 CoT 写出推理：找到订单表、限定华东区、提取两个季度的日期范围、分别求和、再计算差值，最后生成可执行的 SQL 并附上验算逻辑。

教育辅导机器人：逐步讲解题目

阶段：教学内容生成 / 对话系统

解决的问题：学生需要的不是答案，而是“为什么”。思维链让辅导机器人把解题步骤完整展示出来，既帮助学生理解，也方便老师检查机器人的讲解是否正确。

具体案例：学生问“鸡兔同笼”问题，辅导机器人先设未知数，再列方程，然后一步步化简，最后给出答案。如果某一步出错，学生可以指着那一步追问，机器人也能针对该步重新解释。

Python 演示

python55 行
def make_standard_prompt(question):    return "问题:" + question + "\n答案:"  def make_zero_shot_cot_prompt(question):    return "问题:" + question + "\n答案:让我们一步一步地想。"  def make_few_shot_cot_prompt(question, examples):    prompt = ""    for q, r, a in examples:        prompt += "问题:" + q + "\n思考:" + r + "\n答案:" + a + "\n\n"    prompt += "问题:" + question + "\n思考:"    return prompt  def mock_llm(prompt, price, count, discount):    total = price * count    final = total - discount    if "让我们一步一步地想" in prompt:        steps = [            "第1步:单价" + str(price) + "元 x 数量" + str(count) + "本 = " + str(total) + "元",            "第2步:总价" + str(total) + "元 - 优惠" + str(discount) + "元 = " + str(final) + "元"        ]        return steps + ["答案:" + str(final) + "元"]    if prompt.endswith("思考:"):        return [            "第1步:单价" + str(price) + "元 x 数量" + str(count) + "本 = " + str(total) + "元",            "第2步:总价" + str(total) + "元 - 优惠" + str(discount) + "元 = " + str(final) + "元",            "答案:" + str(final) + "元"        ]    return ["答案:" + str(final) + "元"]  def show_prompt(title, prompt, outputs):    print("==" + title + "==")    print(prompt)    print("模型输出:")    for line in outputs:        print(" - " + line)    print()  if __name__ == "__main__":    question = "每本书12元,买4本,再减5元优惠,共付多少?"    print("标准提示词:")    show_prompt("standard", make_standard_prompt(question), mock_llm(make_standard_prompt(question), 12, 4, 5))    print("Zero-shot CoT:")    show_prompt("zero shot", make_zero_shot_cot_prompt(question), mock_llm(make_zero_shot_cot_prompt(question), 12, 4, 5))    examples = [        ("一个苹果2元,买3个,共几元?", "第1步:2x3=6元", "6元"),        ("一支笔5元,买2支,再减3元,共几元?", "第1步:5x2=10元,第2步:10-3=7元", "7元")    ]    print("Few-shot CoT:")    show_prompt("few shot", make_few_shot_cot_prompt(question, examples), mock_llm(make_few_shot_cot_prompt(question, examples), 12, 4, 5))
目的：模拟对比标准提示词、Zero-shot CoT 和 Few-shot CoT 的输出差异，帮你直观看到“多一步推理”带来的变化。
  1. def make_standard_prompt(question):只要求模型输出答案，对应“导航只说到了”。
  2. def make_zero_shot_cot_prompt(question):在问题后拼上“让我们一步一步地想”，触发模型展开中间步骤。
  3. def make_few_shot_cot_prompt(question, examples):用循环拼接示例，让模型模仿“问题-思考-答案”的格式。
  4. if "让我们一步一步地想" in prompt:判断是否为 Zero-shot CoT，模拟模型优先输出推理过程。
  5. return ["答案:" + str(final) + "元"]标准提示词只给最终答案，对应“直接跳到终点”。

常见误区

误区我以为只要在 python 末尾加上“请一步一步思考”，大模型就会自动变成数学天才，什么题都能算对。

正解这句触发语只是让模型把“猜测答案”变成“生成推理过程”。它增加了中间步骤的可验证性，但不保证每一步都对；如果步骤错了，最终答案照样错。就像导航说“直行 100 米”，但它真的开进河里，目的地仍然到不了。需要配合校验、示例和任务难度来选择是否使用。

为何常见：因为 Zero-shot CoT 在宣传中效果很惊艳，容易让人误以为它是万能开关。

误区看到思维链输出“第1步、第2步”，就觉得模型像人类一样理解了逻辑。

正解大模型的生成是基于概率的文本组合，思维链只是它生成的一段与问题相关的文本。步骤可以编造，甚至自相矛盾。它不是人脑中的认知过程，而是“把问题拆解成可观察的文本”。导航中的语音可以播报，但汽车并没有路感。

为何常见：人看到连贯的推理文字，会产生“它懂我”的拟人化错觉。

误区我平时只写文案，不做数学题，所以思维链跟我没关系。

正解CoT 适用于需要多步推理的任何任务：逻辑判断、代码调试、数据清洗、合同条款梳理、SQL 生成、客户投诉处理。只要任务里有多个条件或因果关系，就能把中间步骤显式化。导航不只用于找火车站，也用于一步步找到商店、医院、朋友家。

为何常见：因为 CoT 论文和教程最喜欢拿数学题举例，让人误以为它只是算术技巧。

误区既然思维链是分步骤思考，那我就让模型写一百步，越详细越准确。

正解步骤过长会浪费 token，也可能引入更多的幻觉和累积误差。每一步多一次出错机会，就像导航如果每 3 米播报一次，反而会让人不知道往哪拐。设计时要把步骤控制在能把问题讲清楚的最小数量。

为何常见：把“显式推理”误解为“叙述长度”，忽略了有效信息密度。

误区Few-shot CoT 就是多给几个例子，示例答案随便对就行。

正解示例是模型模仿的路线样本；如果示例本身跳步、格式混乱，模型会更可能模仿坏习惯。高质量 Few-shot 示例应包含清晰的问题、分步推理和标准格式的答案，就像给导航录入准确的路口，而不是对着错误地图指路。

为何常见：看到“示例越多越好”的经验，忽略示例质量比数量更重要。

面试题

Q1. 思维链（Chain-of-Thought）最核心的做法是？

单选题 · easy

  • A.让模型直接输出最终答案
  • B.让模型一步步写出中间推理← 正确答案
  • C.让模型只回答问题不解释
  • D.让模型把答案隐藏起来

答案：B。思维链的核心是让模型先输出中间推理步骤，再给出最终答案。选项 A、C 都是标准提示词的做法，D 则与思维链完全相反。

Q2. Zero-shot CoT 的常见触发方式是？

单选题 · easy

  • A.在问题后加上“让我们一步一步地想”← 正确答案
  • B.在问题前粘贴大量历史聊天记录
  • C.把答案用大写字母重写一遍
  • D.在问题里插入随机数字和符号

答案：A。Zero-shot CoT 的关键是不给示例，只靠一句触发语让模型展开推理。“让我们一步一步地想”是最经典的触发语。B、C、D 都不会稳定引导模型思考。

Q3. 与标准 Prompt 相比，CoT 最大的不同是？

单选题 · easy

  • A.把推理过程显式地展示出来← 正确答案
  • B.让模型使用更大的参数量
  • C.让答案变得更简短更干练
  • D.要求模型必须联网搜索

答案：A。标准 Prompt 往往直接输出答案，CoT 则把推理过程显式化。参数量是模型本身属性，提示词无法改变；CoT 通常让答案更长，也不依赖联网。

Q4. Few-shot CoT 中每个示例最好包含哪三部分？

单选题 · mid

  • A.问题、推理过程、最终答案← 正确答案
  • B.标题、正文、参考文献
  • C.主题、关键词、字数统计
  • D.用户、时间、网络状态

答案：A。Few-shot CoT 的示例必须让模型看到“怎么推理”和“怎么输出”。问题、推理过程、最终答案这三要素是模型模仿的完整路线。B、C、D 与推理无关。

Q5. 为什么 CoT 能提升数学应用题正确率？

单选题 · mid

  • A.因为它把多步计算拆成可检查的小步← 正确答案
  • B.因为它会用快速幂算法加速计算
  • C.因为它禁止模型使用加法和减法
  • D.因为它把数值结果转成图表显示

答案：A。数学应用题的难点是多步运算容易跳步。CoT 把计算过程拆成小步，每一步都可检查。快速幂、禁止加减、转图表都不是 CoT 的机制。

Q6. 在逻辑推理题中，CoT 的主要价值在于？

单选题 · mid

  • A.把条件关系逐步展开并排除矛盾← 正确答案
  • B.用更多汉字填充输出长度
  • C.让模型记住所有百科知识
  • D.把每个条件重复五遍

答案：A。逻辑推理需要处理条件和因果。CoT 将条件关系逐步展开，帮助模型排除矛盾。单纯增加字数和重复条件并不能提升推理质量。

Q7. 下列哪些是设计 CoT 提示词时的注意点？

多选题 · mid

  • A.控制步骤粒度，避免过度拆解← 正确答案
  • B.示例格式保持一致← 正确答案
  • C.把正确答案直接写进提示词
  • D.检查中间步骤是否合理← 正确答案

答案：ABD。好的 CoT 提示词需要适中的步骤粒度、统一的示例格式，并且要人工检查中间步骤是否合理。把正确答案写进提示词属于作弊式提示，在实际推理任务中不可用。

Q8. 为什么说思维链不是模型“真正思考”的证据？

单选题 · hard

  • A.因为它只是概率生成的文本模式← 正确答案
  • B.因为它总是输出正确答案
  • C.因为模型完全没有内部状态
  • D.因为思维链只在中文里有效

答案：A。思维链输出的是模型基于概率生成的文本，哪怕看起来有理，也不代表模型像人一样思考。模型可以编造步骤，也可能自相矛盾。C 的说法过于绝对，模型有内部状态，只是不一定是“思考”。

Q9. 关于 Few-shot CoT，正确的说法有哪些？

多选题 · hard

  • A.示例质量比示例数量更重要← 正确答案
  • B.示例里可以随意跳过关键步骤
  • C.格式混乱会误导模型模仿← 正确答案
  • D.示例越多效果一定单调上升

答案：AC。Few-shot CoT 中，示例质量、格式一致性比数量更重要。跳步或格式混乱的示例会把模型带偏。示例数量增加并不一定带来单调提升，反而可能引入噪声。

Q10. 在上下文窗口受限时，设计 CoT 提示词应优先怎么做？

单选题 · extreme

  • A.压缩步骤长度并聚焦关键推理← 正确答案
  • B.让模型生成无限长的推理文本
  • C.把所有示例全部塞入提示词
  • D.奖励模型写更多无关细节

答案：A。上下文窗口有限，CoT 提示词必须控制总 token。压缩每个步骤的长度、聚焦关键推理，才能在有限空间内完成有效思考。无限长文本、全量示例和无关细节都会迅速耗尽窗口。