善良的xwysyy

Reconciling Contradictory Views on the Effectiveness of SFT in LLMs: An Interaction Perspective

Thu, 04 Jun 2026 00:00:00 GMT

作者：Junpeng Zhang, Lei Cheng, Guoxi Zhang, Hua Cai, Qing Xu, Quanshi Zhang（上海交通大学，北京通用人工智能研究院，UniDT）

核心发现：SFT 对 LLM 的有效阶段极其短暂，主要作用是去除噪声交互而非学习新的可靠推理模式。早期去噪阶段之后，继续微调主要引入过拟合交互。

图1：LLM 的复杂推理模式可被分解为少量交互（短语模式），SFT 过程分为短暂去噪阶段和漫长过拟合阶段

图1上半部分展示了交互分解的核心思想：给定一个物理相关的输入 prompt，LLM 的输出得分可以被一个逻辑模型 ϕ(⋅)\phi(\cdot)ϕ(⋅) 忠实地近似，该模型由若干 AND-OR 交互组成。每个交互对应一个短语模式，例如”laws""of""motion”三个词共同出现时贡献 0.41 的效果增益。图1下半部分展示了 SFT 的两阶段动态：先经历短暂的去噪阶段（移除不可泛化、正负相消的噪声交互），随后进入漫长的过拟合阶段（重新学习噪声交互）。

1. 引言#

SFT 作为预训练模型适配下游任务的标准策略，在 LLM 上呈现出矛盾的效果：一方面 Ouyang et al., Chung et al. 等工作认为 SFT 对指令遵循和可用性至关重要，另一方面 Luo et al., Gudibande et al. 等工作发现 SFT 可能导致过拟合、泛化退化甚至灾难性遗忘。

本文不急于裁定 SFT 的有用与否，而是追问一个更根本的科学问题：LLM 内部的哪些因素导致了 SFT 效果的不一致性？ 作者采用 interaction-based explanation 框架来回答这个问题。这里的 interaction 不是 agent 与环境之间的交互，而是指输入词之间的统计协同效应：一组词共同出现时，对模型输出产生超出各自单独贡献之和的额外效果，这个额外效果就是一个 interaction。例如”laws""of""motion”三个词共现时额外贡献 0.41 的预测增益，可以理解为模型内部自发形成的一条”短语级推理电路”。作者追踪这些交互在 SFT 全过程中的涌现、消亡与保留，发现它们的演化模式能很好地解释 SFT 效果的不一致性。

核心发现可归纳为两点：

SFT 主要移除噪声交互，极少学到可靠的新交互。 被移除的交互呈现高阶、正负相消、跨模型不可泛化的特征，属于噪声模式。保留下来的交互则是低阶、正贡献为主、跨模型可泛化的可靠模式。新涌现的交互大部分也是噪声。
去噪阶段极其短暂（约前 1000 步），之后的持续微调主要引入过拟合交互。 过拟合交互的出现与训练/测试 loss 差距扩大高度相关。

实践启示：SFT 确实有效，但有效窗口极短。少量训练样本即可完成去噪，之后继续大规模微调不但收益递减，反而引入过拟合。交互可以作为 SFT 过程中的诊断信号，为 early stopping 提供更原则化的判据。

2. 相关工作#

本文涉及两个研究脉络：

SFT 的争议。 SFT 在 zero-shot 泛化、指令遵循等方面的正面效果得到广泛验证（LIMA、InstructGPT、FLAN 等）。争议主要来自三个方面：SFT 可能使模型过度适配任务格式而削弱 in-context learning 能力（Wang et al., 2022）；SFT 可能只是模仿强模型的回答风格而未获得底层能力（Gudibande et al., 2023）；持续指令微调可能导致灾难性遗忘（Luo et al., 2025）。

基于交互的可解释性。 Ren et al.（2024）证明 DNN 的输出得分可以被少量 AND-OR 交互忠实预测。Zhou et al.（2024）用交互分析 DNN 的泛化能力，Wang et al.（2020）用交互解释对抗迁移性。本文是该框架首次系统性地应用于分析 SFT 过程。

前驱工作	关注点	本文差异
Ren et al., 2024	用 AND-OR 交互忠实分解 DNN 输出	本文将此框架用于追踪 SFT 过程中交互的动态演化
Zhou et al., 2024	交互分析泛化能力	本文聚焦 SFT 场景下交互的涌现、消亡与保留
Gudibande et al., 2023	SFT 可能只是风格模仿	本文从交互层面给出了 SFT 为何”看似有效实则有限”的机制解释

3. 理解 SFT 中 LLM 的表征增益与损失#

3.1 基础：基于交互的可解释性框架#

给定一个 LLM vvv 和包含 nnn 个输入变量（每个变量对应一个词的 embedding）的 prompt x\boldsymbol{x}x，模型的输出得分定义为生成目标 token 序列 [y1,…,ym][y_1, \ldots, y_m][y1,…,ym] 的 log-odds 之和：

v(x)=def∑i=1mlog⁡p(y=yi∣x,yipreceding)1−p(y=yi∣x,yipreceding)v(\boldsymbol{x}) \overset{\text{def}}{=} \sum_{i=1}^{m} \log \frac{p(y=y_i | \boldsymbol{x}, \boldsymbol{y}_i^{\text{preceding}})}{1 - p(y=y_i | \boldsymbol{x}, \boldsymbol{y}_i^{\text{preceding}})}v(x)=def∑i=1mlog1−p(y=yi∣x,yipreceding)p(y=yi∣x,yipreceding)

交互分解的目标是将该输出得分拆解为一组 AND-OR 交互的数值效果之和。逻辑模型 ϕ(x′)\phi(\boldsymbol{x}')ϕ(x′) 由两类交互构成：

AND 交互：集合 TTT 中所有变量都出现时激活，效果为 ITandI_T^{\text{and}}ITand
OR 交互：集合 TTT 中任意变量出现时激活，效果为 ITorI_T^{\text{or}}ITor

Universal matching 性质是该框架的理论基石：逻辑模型 ϕ\phiϕ 在输入的全部 2n2^n2n 个 mask 状态上都能精确逼近 LLM 的输出，即 ∀x′∈Ψ,∣ϕ(x′)−v(x′)∣<ϵ\forall \boldsymbol{x}' \in \Psi, |\phi(\boldsymbol{x}') - v(\boldsymbol{x}')| < \epsilon∀x′∈Ψ,∣ϕ(x′)−v(x′)∣<ϵ。Ren et al.（2024）进一步证明每个输入样本的显著交互数量有界，实践中通常在 50-150 之间。

计算层面，精确提取交互的代价与 Shapley 值类似呈指数级，但已有 Sparse Mobius Transform（O(nKlog⁡n)O(nK\log n)O(nKlogn)）、SpEx、ProxySPEX 等近似算法将其压缩到可操作范围。

3.2 三类交互的定义与质量度量#

作者将 SFT 过程中的交互分为三类，设 Ωtand\Omega_t^{\text{and}}Ωtand、Ωtor\Omega_t^{\text{or}}Ωtor 为经过 ttt 步 SFT 后的 AND/OR 交互集合：

Removed interactions Rttype=Ω0type∖Ωttype\boldsymbol{R}_t^{\text{type}} = \Omega_0^{\text{type}} \setminus \Omega_t^{\text{type}}Rttype=Ω0type∖Ωttype：SFT 前存在但被消除的交互
Preserved interactions Pttype=Pt−1type∩Ωttype\boldsymbol{P}_t^{\text{type}} = \boldsymbol{P}_{t-1}^{\text{type}} \cap \Omega_t^{\text{type}}Pttype=Pt−1type∩Ωttype：SFT 全程保留的交互
Newly emerged interactions Ettype=Ωttype∖Pttype\boldsymbol{E}_t^{\text{type}} = \Omega_t^{\text{type}} \setminus \boldsymbol{P}_t^{\text{type}}Ettype=Ωttype∖Pttype：SFT 中新学到的交互

两个核心质量度量：

Metric 1：可泛化交互比例 γ\gammaγ。引入一个架构不同的 baseline LLM v′v'v′，交互 SSS 在 vvv 和 v′v'v′ 中同时出现且效果方向一致则视为可泛化。γ\gammaγ 度量可泛化交互效果占总效果的比例。

γ(Ωand,Ωor)=∑type∑S∈Ωtype∣IStype⋅GStype∣∑type∑S∈Ωtype∣IStype∣×100%\gamma(\Omega^{\text{and}}, \Omega^{\text{or}}) = \frac{\sum_{\text{type}} \sum_{S \in \Omega^{\text{type}}} |I_S^{\text{type}} \cdot \mathcal{G}_S^{\text{type}}|}{\sum_{\text{type}} \sum_{S \in \Omega^{\text{type}}} |I_S^{\text{type}}|} \times 100\%γ(Ωand,Ωor)=∑type∑S∈Ωtype∣IStype∣∑type∑S∈Ωtype∣IStype⋅GStype∣×100%

Metric 2：未相消交互效果比例 ρ\rhoρ。度量正负效果相消后残余效果占总绝对效果的比例。ρ\rhoρ 接近零意味着正负效果强烈相消，交互对预测贡献甚微，更可能是噪声。

ρ(Ωand,Ωor)=∣∑type∑S∈ΩtypeIStype∣∑type∑S∈Ωtype∣IStype∣×100%\rho(\Omega^{\text{and}}, \Omega^{\text{or}}) = \frac{|\sum_{\text{type}} \sum_{S \in \Omega^{\text{type}}} I_S^{\text{type}}|}{\sum_{\text{type}} \sum_{S \in \Omega^{\text{type}}} |I_S^{\text{type}}|} \times 100\%ρ(Ωand,Ωor)=∑type∑S∈Ωtype∣IStype∣∣∑type∑S∈ΩtypeIStype∣×100%

交互的 order/complexity 定义为涉及的输入变量数 ∣T∣|T|∣T∣。已有研究表明低阶交互对噪声更鲁棒、跨模型泛化性更强。作者进一步将每类交互按 order 展开为分布向量（如新涌现正交互的分布 e+=[e(1),+,…,e(n),+]T\boldsymbol{e}^+ = [\text{e}^{(1),+}, \ldots, \text{e}^{(n),+}]^Te+=[e(1),+,…,e(n),+]T），为可视化交互演化提供基础。

3.3 SFT 的角色：去噪而非可靠表征学习#

实验设置。 在 GoEmotions、Unilaw-R1-Data、Databricks-Dolly-15k 三个数据集上对 Qwen2.5-3B/7B-Instruct、Llama-2-7B-Chat、Llama-3-8B-Instruct、Gemma-3-4B-it 进行 LoRA SFT（rank=8，lr=1e-4，有效 batch size=64）。

图2：SFT 过程中三类交互分布的演化（Llama-3-8B-Instruct 和 Qwen2.5-7B-Instruct 在 GoEmotions 上）

图2的全景视图非常信息密集。每行对应一个模型，三列分别展示新涌现、被移除、保留交互的 order 分布随训练步数的变化。绿色区域标记去噪阶段，紫色区域标记过拟合阶段。关键观察：去噪阶段中，大量高阶、正负对称的交互被移除，仅保留少量低阶交互；进入过拟合阶段后，大量高阶且正负相消的新交互重新涌现。

五个核心发现：

Finding 1：去噪阶段新涌现交互极少，过拟合阶段新涌现交互大量增加。 从交互数量和总强度两个维度看，绝大部分新涌现交互出现在第二阶段。

Finding 2：第一阶段涌现的少量交互更可泛化，第二阶段涌现的大量交互更像噪声。 三重证据支撑此结论：(i) 第二阶段交互多为高阶；(ii) 第一阶段交互的跨模型泛化性远高于第二阶段；(iii) 第一阶段交互的未相消效果比例远高于第二阶段。

Finding 3：交互移除集中在极短的第一阶段。 绝大部分被移除的交互在前 ~1000 步内就被清除，第二阶段几乎不再移除交互。

Finding 4：被移除交互几乎全是噪声。 (i) 以高阶交互为主；(ii) 跨模型泛化性接近零（γ≈0\gamma \approx 0γ≈0）；(iii) 正负效果几乎完全相消（ρ≈0\rho \approx 0ρ≈0）。

Finding 5：保留交互数量少但质量最高。 (i) 以低阶交互为主；(ii) 超过半数可跨模型泛化（γ>50%\gamma > 50\%γ>50%）；(iii) 正负相消程度最低（ρ\rhoρ 最大）。

图3：三类交互质量的演化，用泛化性 γ 和未相消比例 ρ 度量

图3直观展示了质量演化趋势。上行为 γ\gammaγ（可泛化比例），下行为 ρ\rhoρ（未相消比例），分别在四个模型-数据集组合上绘制。红色曲线（preserved）在两个指标上始终最高；橙色曲线（newly emerged）仅在绿色区域（去噪阶段）短暂表现良好，随后迅速衰退；蓝色曲线（removed）两个指标始终接近零。

SFT 的本质是快速去噪加持久过拟合。有效窗口极短（~1000 步），之后继续训练不但不能学到新的可靠模式，反而引入大量噪声交互。

3.4 保留交互是 LLM 推理的骨干吗？#

作者从三个角度验证假设：SFT 后保留下来的少量交互构成了目标 token 预测的核心骨干。

(1) 正负相消验证。 保留交互的 ρ\rhoρ 值最高，新涌现和被移除交互的效果大量正负相消，表明后两者主要编码噪声。

(2) 单交互平均贡献。 保留交互和去噪阶段早期涌现交互的单交互平均贡献显著大于被移除交互和过拟合阶段涌现交互。

(3) 仅用保留交互的预测能力。 将各类交互单独用于 token 预测（通过将交互效果之和输入 sigmoid 逆函数恢复概率），计算测试 cross-entropy loss。保留交互和早期涌现交互产生的 loss 显著低于被移除交互和后期涌现交互。

图4：不同类型交互的预测效用与单交互贡献对比

图4上行展示四个模型设定下各类交互的测试 cross-entropy loss：preserved 和 emerged in 1st stage 的 loss 远低于 removed 和 emerged in 2nd stage。下行展示单交互平均贡献，preserved 和早期 emerged 的贡献量级远大于其他两类（注意 Llama-2-7B-Chat 的 y 轴标注为 1e-2 量级）。

保留交互加上去噪阶段少量新涌现交互，共同构成 LLM 推理的骨干。SFT 后期涌现的大量交互对预测几乎没有实质贡献。

4. 结论与讨论#

交互框架为 SFT 的”矛盾效果”给出了统一解释。SFT 的净贡献可以概括为：在极短的窗口内高效清除预训练模型中的噪声推理模式，同时识别并强化已有的可靠模式。这个窗口过后，持续微调主要产生过拟合交互。

实践层面的三个含义：(1) 交互分布可作为 SFT 过程的诊断信号，当新涌现交互从低阶转向高阶、ρ\rhoρ 开始下降时，即为 early stopping 的合理时机；(2) 大规模 SFT 数据集的边际价值可能远低于预期，少量高质量数据即可完成去噪；(3) 端到端 SFT 之后的继续训练需要更审慎的评估。

参考链接：

论文地址：https://arxiv.org/abs/2605.17967

强化学习算法梳理：从 PPO 到 GRPO 及之后

Mon, 25 May 2026 00:00:00 GMT

https://zhuanlan.zhihu.com/p/2001404871753102054
https://aweers.de/blog/2026/rl-for-llms

强化学习是 LLM 后训练流程中最具影响力的技术之一。GPT-3 到 InstructGPT 的跨越依赖于它 [1]，而后 OpenAI o1 [2] 和 DeepSeek-R1 [3] 在推理能力上的突破同样以 RL 为核心。

第一代方法以 PPO [4] 为代表。PPO 原本是为 Atari 游戏和机器人控制等传统 RL 场景设计的，后被成功适配到 RLHF 中。

第二代方法的目标转向推理能力，带来了一轮密集的算法迭代。短时间内出现了大量变体，多数只在前人基础上做了小幅但关键的改动。

本文梳理 2024–2026 年间推理 LLM 强化学习的主要进展，从 REINFORCE 和 PPO 讲起，再依次介绍 GRPO 及后续的改进方法。

强化学习基础#

在标准 RL 设定中，智能体（agent） 在每个时间步观察状态 sts_tst，根据策略 π(at∣st)\pi(a_t \mid s_t)π(at∣st) 选择动作 ata_tat，按环境动力学 p(st+1∣st,at)p(s_{t+1} \mid s_t, a_t)p(st+1∣st,at) 转移到新状态 st+1s_{t+1}st+1，并获得奖励 rtr_trt。

举个具体例子：一个在房间中导航的机器人，状态是当前位置和传感器读数，动作是运动指令，状态转移由物理规律（轮子可能打滑）决定，奖励反映朝目标的进展。

这一循环重复 TTT 个时间步，智能体的目标是最大化期望折扣回报

J=E[∑t=0Tγtrt]J = \mathbb{E}\left[\sum_{t=0}^{T} \gamma^t r_t\right]J=E[t=0∑Tγtrt]

其中折扣因子 0≤γ≤10 \leq \gamma \leq 10≤γ≤1 控制对未来奖励的折扣程度。

策略通常由参数 θ\thetaθ 参数化。许多 RL 算法中的核心概念是价值函数

Vπ(s)=Eπ[∑l=0T−tγlrt+l∣st=s],V^\pi(s) = \mathbb{E}_\pi\left[\sum_{l=0}^{T-t} \gamma^l r_{t+l} \mid s_t = s\right],Vπ(s)=Eπ[l=0∑T−tγlrt+l∣st=s],

它衡量在策略 π\piπ 下处于状态 sss 的期望回报。由此可以推导出优势（advantage），用于估计某个动作是优于还是劣于期望表现。

在 LLM 场景中，这一设定通常被大幅简化。我们有一个参数化模型 πθ\pi_\thetaπθ，给定数据集中的提示 x∼Dx \sim \mathcal{D}x∼D，采样回复 y∼πθ(⋅∣x)y \sim \pi_\theta(\cdot|x)y∼πθ(⋅∣x)，并用标量奖励 r(x,y)r(x, y)r(x,y) 进行评分。优化目标变为：

J(θ)=Ex∼D, y∼πθ(⋅∣x)[r(x,y)]J(\theta) = \mathbb{E}_{x \sim \mathcal{D},\, y \sim \pi_\theta(\cdot|x)}\left[r(x, y)\right]J(θ)=Ex∼D,y∼πθ(⋅∣x)[r(x,y)]

当然，仍然可以将这个环境建模为：状态 =（提示 + 已生成 token），动作 = 下一个 token。但实际中通常无法对单个 token 赋予有意义的奖励，只能对给定提示的完整回复给出一个奖励。除最后一个 token 外所有 token 的奖励都是零，这使建模变得不必要地复杂。

REINFORCE#

从 REINFORCE [5] 开始，因为它概念简洁，且是所有策略梯度方法的基础。

最简形式下，REINFORCE 的目标是：

J(θ)=Ey∼πθ(⋅∣x)[r(x,y)]J(\theta) = \mathbb{E}_{y \sim \pi_\theta(\cdot \mid x)}\left[r(x, y)\right]J(θ)=Ey∼πθ(⋅∣x)[r(x,y)]

其梯度有一个简洁且直观的形式：

∇θJ(θ)=Ey∼πθ(⋅∣x)[∇θlog⁡πθ(y∣x)⋅r(x,y)]\nabla_\theta J(\theta) = \mathbb{E}_{y \sim \pi_\theta(\cdot \mid x)}\left[\nabla_\theta \log \pi_\theta(y \mid x) \cdot r(x, y)\right]∇θJ(θ)=Ey∼πθ(⋅∣x)[∇θlogπθ(y∣x)⋅r(x,y)]

作为对比，监督微调（SFT）的梯度为

∇θLSFT(θ)=−∇θlog⁡πθ(y∗∣x)\nabla_\theta L_{\text{SFT}}(\theta) = -\nabla_\theta \log \pi_\theta(y^* \mid x)∇θLSFT(θ)=−∇θlogπθ(y∗∣x)

（注意 SFT 损失是最小化的，而 RL 目标是最大化的。）

由此可以看出，REINFORCE 本质上是加权版的 SFT。区别在于：SFT 强化的是给定的、off-policy 的答案 y∗y^*y∗，而 REINFORCE 根据奖励对采样的、on-policy 的答案 yyy 进行强化或惩罚。

REINFORCE 的主要缺点是方差大。即使奖励结构相对有序（例如一个大型测试套件中每个测试贡献部分奖励），梯度估计在不同样本间仍可能有很大波动。

为降低方差，REINFORCE 引入了一个不依赖于采样动作（回复）的基线 b(x)b(x)b(x)。由于

Ey∼πθ(⋅∣x)[∇θlog⁡πθ(y∣x) b(x)]=0,\mathbb{E}_{y \sim \pi_\theta(\cdot \mid x)}\left[\nabla_\theta \log \pi_\theta(y \mid x)\, b(x)\right] = 0,Ey∼πθ(⋅∣x)[∇θlogπθ(y∣x)b(x)]=0,

减去基线不改变梯度的期望，但通常能显著降低方差。梯度变为

∇θJ(θ)=Ey∼πθ(⋅∣x)[∇θlog⁡πθ(y∣x) (r(x,y)−b(x))].\nabla_\theta J(\theta) = \mathbb{E}_{y \sim \pi_\theta(\cdot \mid x)}\left[\nabla_\theta \log \pi_\theta(y \mid x)\, \bigl(r(x,y)-b(x)\bigr)\right].∇θJ(θ)=Ey∼πθ(⋅∣x)[∇θlogπθ(y∣x)(r(x,y)−b(x))].

其中 r(x,y)−b(x)r(x,y)-b(x)r(x,y)−b(x) 是优势估计的最简形式。

PPO#

PPO（Proximal Policy Optimization）[4] 成为了最主流的通用策略梯度算法，并在相当长一段时间内是 RLHF 的默认选择。

PPO 的目标函数通常以一个看起来比较复杂的形式呈现：

JPPO(θ)=Et[min⁡(ρt(θ)A^t, clip⁡(ρt(θ),1−ϵ,1+ϵ)A^t)],J^{\text{PPO}}(\theta) = \mathbb{E}_t\left[\min\left(\rho_t(\theta)\hat{A}_t,\; \operatorname{clip}(\rho_t(\theta), 1-\epsilon, 1+\epsilon)\hat{A}_t\right)\right],JPPO(θ)=Et[min(ρt(θ)A^t,clip(ρt(θ),1−ϵ,1+ϵ)A^t)],

其中

ρt(θ)=πθ(at∣st)πθold(at∣st)\rho_t(\theta) = \frac{\pi_\theta(a_t \mid s_t)}{\pi_{\theta_{\text{old}}}(a_t \mid s_t)}ρt(θ)=πθold(at∣st)πθ(at∣st)

是当前策略 πθ\pi_\thetaπθ 与生成 rollout 时的策略 πθold\pi_{\theta_\text{old}}πθold 之间的重要性采样（IS）比率。

一个自然的疑问是：“对于 on-policy RL，这个比率不应该总是 1 吗？“答案是：只在生成 rollout 后的第一步优化时如此。

这个比率存在的原因是 rollout 的生成成本很高。实际中通常会将一批生成的数据复用于多个 minibatch 更新或多个 epoch。第一步优化之后，训练策略就不再完全等同于生成策略，PPO 因此变得略微 off-policy。比率对这一不匹配进行修正，而裁剪则限制优化偏离生成策略的幅度。这是 PPO 对信赖域 [6] 的一种近似。

需要注意的是，裁剪不仅影响目标函数的值，更重要的是影响它对 θ\thetaθ 的依赖关系。由于我们通过优化 θ\thetaθ 来最大化 JJJ，被裁剪的情况会产生零梯度——因为学习策略已不在等式中。这些情况下的更新被跳过，因为已经移出了信赖域。

裁剪处理四种场景：

	未裁剪	已裁剪
正优势（好答案，强化）	ρt(θ)A^t\rho_t(\theta)\hat{A}_tρt(θ)A^t：答案好且尚未被过度更新	(1+ϵ)A^t(1+\epsilon)\hat{A}_t(1+ϵ)A^t：该答案已足够可能，梯度停止
负优势（差答案，抑制）	ρt(θ)A^t\rho_t(\theta)\hat{A}_tρt(θ)A^t：答案差且尚未被过度更新	(1−ϵ)A^t(1-\epsilon)\hat{A}_t(1−ϵ)A^t：该答案已足够不可能，梯度停止

也可以将裁剪表示为一个掩码：

M(A^t,ρt,ϵ)={0if (A^t>0∧ρt>1+ϵ)∨(A^t<0∧ρt<1−ϵ)1otherwiseM(\hat{A}_t, \rho_t, \epsilon) = \begin{cases} 0 & \text{if } (\hat{A}_t > 0 \land \rho_t > 1 + \epsilon) \lor (\hat{A}_t < 0 \land \rho_t < 1 - \epsilon) \\ 1 & \text{otherwise} \end{cases}M(A^t,ρt,ϵ)={01if (A^t>0∧ρt>1+ϵ)∨(A^t<0∧ρt<1−ϵ)otherwise

用这一表示，目标函数简化为：

JPPO(θ)=Et[M(A^t,ρt(θ),ϵ) ρt(θ) A^t].J^{\text{PPO}}(\theta) = \mathbb{E}_t\left[M(\hat{A}_t,\rho_t(\theta),\epsilon)\,\rho_t(\theta)\,\hat{A}_t\right].JPPO(θ)=Et[M(A^t,ρt(θ),ϵ)ρt(θ)A^t].

因此，PPO 本质上是带有信赖域掩码的重要性加权策略梯度。

PPO Loss 示意

在优势估计方面，PPO 使用广义优势估计器（GAE）：

A^t=∑l=0∞(γλ)lδt+l\hat{A}_t = \sum_{l=0}^{\infty} (\gamma \lambda)^l \delta_{t+l}A^t=l=0∑∞(γλ)lδt+l

计算 δ\deltaδ 需要一个学习得到的价值函数。在 LLM 场景下，这通常需要一个额外的价值模型，其规模往往与策略模型相当，内存开销很大，也增加了训练复杂度。本文不详细展开 GAE，因为去除这一组件正是 GRPO 的主要实际贡献。关于 PPO 各组件的详细解释，可参考这篇详细博文。

最后，PPO 目标函数常与 KL 正则化结合：

JPPO-KL(θ)=Et[M(A^t,ρt,ϵ)ρt(θ)A^t]−β DKL(πθ ∥ πref).J^{\text{PPO-KL}}(\theta) = \mathbb{E}_t\left[M(\hat{A}_t,\rho_t,\epsilon)\rho_t(\theta)\hat{A}_t\right] - \beta\, D_{\text{KL}}(\pi_\theta \,\|\, \pi_{\text{ref}}).JPPO-KL(θ)=Et[M(A^t,ρt,ϵ)ρt(θ)A^t]−βDKL(πθ∥πref).

其中 πref\pi_{\text{ref}}πref 通常是 RL 训练前的模型。在 RLHF 中这一项尤为重要，因为它保持通用能力，并控制相对于奖励模型（在参考策略 πref\pi_{\text{ref}}πref 上训练）的分布偏移。在推理 RL 中，KL 惩罚通常被设得很小或直接省略 [3], [7]。

完整形式的 PPO 需要在内存中保存四个大型组件：可训练策略、rollout 策略、参考策略和价值模型。

GRPO#

GRPO（Group Relative Policy Optimization）由 DeepSeekMath 提出，后在 DeepSeek-R1 中广泛使用 [8], [3]，去掉了 PPO 的价值模型，代之以组内相对基线。

GRPO 算法总览

核心思路是：通过将一个回复与同一提示下的其他回复比较，就能得到一个好的基线。对每个提示 x∼Dx \sim \mathcal{D}x∼D，GRPO 采样一组 GGG 个回复 {y1,…,yG}\{y_1, \ldots, y_G\}{y1,…,yG}，计算奖励 ri=r(x,yi)r_i = r(x, y_i)ri=r(x,yi)，并在组内归一化奖励得到优势：

A^i=ri−μGσG,μG=1G∑j=1Grj,σG=1G∑j=1G(rj−μG)2.\hat{A}_i = \frac{r_i - \mu_G}{\sigma_G}, \qquad \mu_G = \frac{1}{G}\sum_{j=1}^{G} r_j, \qquad \sigma_G = \sqrt{\frac{1}{G}\sum_{j=1}^{G}(r_j-\mu_G)^2}.A^i=σGri−μG,μG=G1j=1∑Grj,σG=G1j=1∑G(rj−μG)2.

直觉上，每条 rollout 的基线不再是学习得到的价值函数，而是同一提示下其他 rollout 的表现。当奖励稀疏但每个提示可获得多个采样时，这一方法效果尤其好。

GRPO 保留了 PPO 风格的裁剪重要性采样，原始形式中包含 KL 项：

JGRPO(θ)=Ex∼D[1G∑i=1Gmin⁡(ρi(θ)A^i, clip(ρi(θ),1−ϵ,1+ϵ)A^i)−β⋅DKL(πθ(⋅∣x)∥πref(⋅∣x))]J^{\text{GRPO}}(\theta) = \mathbb{E}_{x \sim \mathcal{D}}\left[\frac{1}{G}\sum_{i=1}^{G} \min\left(\rho_i(\theta) \hat{A}_i,\, \text{clip}(\rho_i(\theta), 1-\epsilon, 1+\epsilon) \hat{A}_i\right) - \beta \cdot D_{\text{KL}}(\pi_\theta(\cdot|x) \| \pi_{\text{ref}}(\cdot|x))\right]JGRPO(θ)=Ex∼D[G1i=1∑Gmin(ρi(θ)A^i,clip(ρi(θ),1−ϵ,1+ϵ)A^i)−β⋅DKL(πθ(⋅∣x)∥πref(⋅∣x))]

其中 ρi(θ)=πθ(yi∣x)πθold(yi∣x)\rho_i(\theta)=\frac{\pi_\theta(y_i \mid x)}{\pi_{\theta_{\text{old}}}(y_i \mid x)}ρi(θ)=πθold(yi∣x)πθ(yi∣x)。

组内归一化有两个有益的效果。减去均值使学习信号变为提示相对的：如果某提示下所有采样的奖励都在 [0.8,1.0][0.8, 1.0][0.8,1.0]，那么 0.80.80.8 的含义与所有采样在 [0.2,0.8][0.2, 0.8][0.2,0.8] 时完全不同。除以标准差使方法对奖励尺度不敏感，在混合不同奖励范围的任务时有用。

但 GRPO 成功的更重要原因其实更简单：它去掉了 critic。这显著减少了内存占用，使大规模推理模型的 RL 训练变得更加可行。

GRPO 的实现流程#

具体来说，GRPO 的一轮迭代可分为如下几个阶段：

阶段一：生成与冻结。 这是 GRPO 与 DPO 最大的区别——DPO 使用静态数据，而 GRPO 必须让旧模型现场生成数据。对每个问题 qqq，使用当前旧策略 πold\pi_{\text{old}}πold 自回归生成 GGG 个回答（通常 G=64G=64G=64），同时记录每个 token 的对数概率作为常量张量，供后续计算 ratio 使用。

阶段二：奖励评估。 将 GGG 个完整回答送入奖励模型或规则校验器（如数学题验证答案正确性），得到标量奖励 {r1,…,rG}\{r_1, \ldots, r_G\}{r1,…,rG}。

阶段三：优势计算。 对 GGG 个奖励做组内归一化，得到每个回答的优势 A^i\hat{A}_iA^i。不需要 critic 网络，小组平均分就是 baseline。

阶段四：策略评估。 将旧模型生成的固定文本喂给待更新模型 πθ\pi_\thetaπθ 做 Teacher Forcing 前向传播——新模型不生成新 token，只评估旧模型产出的每个 token 在当前参数下的概率。由于新旧模型评估的是同一段固定文本，概率向量长度完全一致，可以逐 token 计算比率 ρt=πθ(ot)/πold(ot)\rho_t = \pi_\theta(o_t) / \pi_{\text{old}}(o_t)ρt=πθ(ot)/πold(ot)。Ratio > 1 表示新模型更倾向于生成该 token，< 1 则相反。

阶段五：计算 PPO Loss。 结合优势 A^i\hat{A}_iA^i（整句共享）和每个 token 的 ratio，计算裁剪后的 surrogate loss。

阶段六–七：反向传播与迭代。 更新参数后，丢弃旧策略，用更新后的模型作为新的 πold\pi_{\text{old}}πold，回到阶段一开始下一轮。

GRPO 的改进空间#

GRPO 虽然简洁高效，但存在若干可优化的方向，后续方法围绕这些方向展开：

优势计算：标准差归一化是否必要？组级 vs 批次级归一化？（→ Dr. GRPO, DAPO）
裁剪机制：对称裁剪是否过于保守？能否解耦上下界？（→ DAPO, CISPO, SAPO）
损失聚合：样本级平均是否引入长度偏差？（→ Dr. GRPO, DAPO, GSPO）
采样策略：全对/全错的提示浪费梯度怎么办？（→ DAPO 动态采样, GFPO, NGRPO）
信用分配：整句共享同一个 advantage 是否太粗？（→ VAPO, token 级方法）
多目标奖励：多个奖励求和后归一化是否丢失分辨力？（→ GDPO）

RLOO#

RLOO（REINFORCE Leave-One-Out）[9] 从不同方向得出了类似结论：PPO 对于 LLM 微调场景来说可能过于复杂¹。

对每个提示，RLOO 采样 KKK 个回复 {y1,…,yK}\{y_1, \ldots, y_K\}{y1,…,yK}。回复 yiy_iyi 的优势是其奖励减去其余 K−1K-1K−1 个回复的平均奖励：

A^i=ri−1K−1∑j≠irj\hat{A}_i = r_i - \frac{1}{K-1}\sum_{j \neq i} r_jA^i=ri−K−11j=i∑rj

这个基线是无偏的，且不需要学习的价值模型。与 GRPO 不同，RLOO 不除以组内标准差。

更重要的是，RLOO 放弃了 PPO 风格的裁剪，回归纯粹的 REINFORCE 式更新。RLOO 目标为：

JRLOO(θ)=Ex∼D[1K∑i=1K∇θlog⁡πθ(yi∣x)⋅A^i]J^{\text{RLOO}}(\theta) = \mathbb{E}_{x \sim \mathcal{D}}\left[\frac{1}{K}\sum_{i=1}^{K} \nabla_\theta \log \pi_\theta(y_i|x) \cdot \hat{A}_i\right]JRLOO(θ)=Ex∼D[K1i=1∑K∇θlogπθ(yi∣x)⋅A^i]

作者指出，在他们的实验中裁剪仅在不到 5% 的情况下被激活，在这一场景下可能并非必要。不过后续工作得出了不同的结论。

Open-Reasoner-Zero：PPO 的反击#

Open-Reasoner-Zero [10] 从另一个角度质疑了 GRPO 的不可替代性：通过精心调整的 PPO 和简单的奖励函数，也能达到类似 R1 的效果。这一工作表明，GRPO 的成功更多在于工程上的高效性（省显存），而非算法理论上的绝对优势。但在算力受限的场景下，GRPO 仍是首选。

Dr. GRPO#

DeepSeek 在 DeepSeek-Math 和 R1 的论文中报告了一个现象：随着 RL 训练推进，回复长度显著增加。他们将此归因于推理和反思能力的提升（即著名的”Aha”时刻）。这可能是原因之一，但 Dr. GRPO（全称”GRPO Done Right”）[11] 的作者发现了一个更重要的原因：标准的样本级损失归一化引入了一个偏差，倾向于短的正确回复和长的错误回复。

在常见的 GRPO 实现中，token 损失先在每个序列内取平均，再在序列间取平均。这意味着固定的序列级奖励被分摊到序列的所有 token 上。因此，长回复如果正确，每个 token 获得的强化信号更弱；如果错误，每个 token 受到的惩罚也更弱。这会产生鼓励冗长的激励。

修复方法很直接：Dr. GRPO 不再先除以序列长度再除以批次大小，而是除以一个固定常数（最大 token 数）。这有效消除了错误答案变得不必要冗长的激励。

Dr. GRPO 还去掉了另一个引入偏差的归一化。当每个提示的奖励按标准差归一化时，对于所有答案奖励相近的提示（例如只有一个错误，奖励方差很低），即使微小的奖励差异也会被放大为很大的归一化优势。结果是，模型在已经基本掌握的提示上反而收到不成比例的大更新。换个角度说，方差高的题目（模型感到困惑、好坏参半的题目）才有利于学习，强制除以方差反而把注意力放在了简单样本上。

Dr. GRPO 的优势简化为：

A^i=ri−μG\hat{A}_i = r_i - \mu_GA^i=ri−μG

不除以标准差，且损失在 token 级别以固定归一化常数聚合，而非先按序列长度取平均。

Dr. GRPO 与 GRPO 对比

这里的实际信息不是 GRPO 有根本性缺陷，而是其中一些看似无害的归一化操作并非中性的。在长链推理中，它们改变了哪些提示和哪些 token 接收到梯度信号。

DAPO【实测有效】#

DAPO（Decoupled Clip and Dynamic sAmpling Policy Optimization）[7] 对 GRPO 的多个组件做了深入分析，提出了四项改进。

改进一：Token 级损失聚合。 与 Dr. GRPO 类似，DAPO 将样本级平均替换为 token 级聚合（DAPO 除以实际 token 数，Dr. GRPO 使用固定常数）。

DAPO 长度问题

Token-Level Loss

改进二：非对称裁剪（Clip-Higher）。 PPO 的对称比率裁剪对低概率 token 过于严格。例如，若某 token 的概率为 0.010.010.01，在 ϵ=0.2\epsilon = 0.2ϵ=0.2 下其概率最多只能升至 0.0120.0120.012 就会被裁剪，几乎不改变其被采样的可能性。这会抑制罕见但有用的推理延续的学习（如 “However”、“Wait” 等在推理轨迹中充当关键分叉点的 token）。DAPO 因此将裁剪边界解耦，使用更大的上界 ϵhigh=0.28\epsilon_{\text{high}} = 0.28ϵhigh=0.28，保持 ϵlow=0.2\epsilon_{\text{low}} = 0.2ϵlow=0.2。

熵坍塌问题

Clip-Higher 策略

结合 token 级聚合和非对称裁剪，DAPO 目标为：

JDAPO(θ)=E[1∑i=1G∣yi∣∑i=1G∑t=1∣yi∣min⁡(ρi,t(θ)A^i, clip⁡(ρi,t(θ),1−ϵlow,1+ϵhigh)A^i)].J^{\text{DAPO}}(\theta) = \mathbb{E}\left[ \frac{1}{\sum_{i=1}^{G}|y_i|} \sum_{i=1}^{G}\sum_{t=1}^{|y_i|} \min\left( \rho_{i,t}(\theta)\hat{A}_i,\; \operatorname{clip}(\rho_{i,t}(\theta),1-\epsilon_{\text{low}},1+\epsilon_{\text{high}})\hat{A}_i \right) \right].JDAPO(θ)=E∑i=1G∣yi∣1i=1∑Gt=1∑∣yi∣min(ρi,t(θ)A^i,clip(ρi,t(θ),1−ϵlow,1+ϵhigh)A^i).

改进三：超长回复奖励塑形（Overlong Reward Shaping）。 在许多设定中，被截断的回复和完全错误的回复获得相同的奖励，这引入了噪声——一个回复可能包含大部分正确推理，只是被长度限制截断了。模型可能学到”只要生成得长就会被惩罚”的错误信号，抑制深度思考能力。DAPO 在硬截断之前增加了一个软惩罚区间：

Rlength(y)={0,∣y∣≤Lmax−Lcache(Lmax−Lcache)−∣y∣Lcache,Lmax−Lcache<∣y∣≤Lmax−1,Lmax<∣y∣.R_\text{length}(y) = \begin{cases} 0, & |y| \le L_\text{max} - L_\text{cache} \\ \frac{(L_\text{max} - L_\text{cache}) - |y|}{L_\text{cache}}, & L_\text{max} - L_\text{cache} < |y| \le L_\text{max} \\ -1, & L_\text{max} < |y|. \end{cases}Rlength(y)=⎩⎨⎧0,Lcache(Lmax−Lcache)−∣y∣,−1,∣y∣≤Lmax−LcacheLmax−Lcache<∣y∣≤LmaxLmax<∣y∣.

Overlong Reward Shaping

改进四：动态采样（Dynamic Sampling）。 如果某个提示的所有采样回复全部正确或全部错误，组内相对优势全为零，该提示不贡献梯度。

梯度消失问题 1

梯度消失问题 2

DAPO 通过过采样和过滤来解决：检查每个 prompt 的生成结果，过滤掉”全对”或”全错”的，持续重新采样直到每个 prompt 都有混合结果。这确保优化批次中的每个提示都提供学习信号，提升了每步效率，但可能增加实际耗时。

VAPO：价值模型的回归#

VAPO（Value-based Augmented Proximal Policy Optimization）[12] 提出了一个不同的观点：虽然 GRPO 通过去掉 critic 提升了效率，但在极其复杂的推理任务上，设计良好的价值模型仍能提供比纯组内对比更精确的指导。

VAPO 通过七项技术实现了”价值模型的回归”：在正式 RL 开始前对价值模型做独立预训练（Value-Pretraining），避免 RL 初期因 critic 乱猜导致的策略崩塌；使用解耦广义优势估计（Decoupled-GAE），将即时反馈与长期价值分离，降低劣质价值模型对策略梯度的干扰；引入长度自适应 GAE，对序列长度做动态调整，防止过长推理路径获得不合理的优势值。

在损失层面，VAPO 采用 token 级策略梯度损失提高学习粒度；在采样上借鉴 GRPO 的组内采样思路；对高分正确样本额外增加语言模型损失，确保不丧失语言流畅度；裁剪机制上使用 Clip-Higher（与 DAPO 思路一致）。

VAPO 的意义在于：critic 并非一定要丢掉，关键在于如何设计好它。

CISPO#

CISPO（Clipped Importance Sampling Policy Optimization）由 MiniMax-M1 报告 [13] 提出，针对 PPO 风格裁剪的一个特定弱点：当 token 超出裁剪范围时，PPO 完全阻断其梯度。

这一行为虽然保守，但也可能过于谨慎。概率发生大幅变化的 token 往往恰恰是对学习推理行为最重要的（报告中提到 “However”、“Recheck”、“Wait”、“Aha” 等 token 在基础模型中概率很低，但在推理轨迹中可能充当关键分叉点）。如果这些 token 在比率过大时就被掩码掉，学习会因丢弃最有信息量的梯度而变慢。

CISPO 因此将裁剪与梯度流解耦。它不对目标函数做产生硬掩码的裁剪，而是只裁剪重要性采样权重，并对该权重施加 stop-gradient 操作：

JCISPO(θ)=E[sg⁡ ⁣(ρ^t(θ)) A^t log⁡πθ(at∣st)],ρ^t(θ)=clip⁡(ρt(θ),1−ϵl,1+ϵh),J^{\text{CISPO}}(\theta) = \mathbb{E}\left[ \operatorname{sg}\!\left(\hat{\rho}_t(\theta)\right)\, \hat{A}_t\, \log \pi_\theta(a_t \mid s_t) \right], \qquad \hat{\rho}_t(\theta)=\operatorname{clip}\bigl(\rho_t(\theta), 1-\epsilon_{l}, 1+\epsilon_{h}\bigr),JCISPO(θ)=E[sg(ρ^t(θ))A^tlogπθ(at∣st)],ρ^t(θ)=clip(ρt(θ),1−ϵl,1+ϵh),

其中 sg⁡(⋅)\operatorname{sg}(\cdot)sg(⋅) 表示 stop-gradient。

一个有趣的发现是，实验中只需要调节上界裁剪 ϵh\epsilon_hϵh，下界 ϵl\epsilon_lϵl 被设为足够大以使其实际上不生效。

这一设计保留了 IS 权重裁剪的降方差效果，同时允许梯度对所有 token 流通。结果是训练更稳定，不会抑制高信息量 token 的学习，且在 MiniMax 的实验中相比 DAPO 实现了 2 倍的步效率提升。

CISPO 可以看作 PPO 风格掩码的软替代：保留信赖域的直觉，但裁剪权重而非删除整个更新。

GSPO：序列级优化#

GSPO（Group Sequence Policy Optimization）[14] 由 Qwen 团队提出，用于训练 Qwen3 系列模型。

GSPO 的核心批判是 GRPO 存在粒度错配：虽然基线是组级的，但重要性采样和更新仍是 token 级的。奖励通常针对整个回答给出（如答案对不对），将这个奖励强行分配给每个 token 并独立裁剪和更新，会引入额外的方差和噪声。

GSPO 的解决方案是将所有操作统一到序列级：不再计算每个 token 的新旧概率比，而是计算整个序列的联合概率比值；对整个序列的权重进行截断，而非对单个 token；同一序列中的所有 token 共享相同的更新幅度。

GSPO 公式

GSPO 在实践中有两个显著优势。对于 MoE 模型，它极大地稳定了 RL 训练，避免了 GRPO 中常见的专家负载崩塌问题。在工程上，由于不需要 token 级的精确对齐，GSPO 允许推理引擎和训练引擎精度不完全一致（如 FP8 vs BF16）的情况下依然稳定训练。

GMPO：几何平均的鲁棒性#

GMPO（Geometric-Mean Policy Optimization）[15] 从统计量的稳健性角度出发。原始 GRPO 在计算 baseline 时使用算术平均，但在 RL 探索初期，奖励分布往往包含极端离群值。算术平均容易被这些离群值拉偏，导致 advantage 和重要性采样比率剧烈波动，进而引发梯度爆炸。

GMPO 提出最大化 token 级奖励或比率的几何平均值而非算术平均值。几何平均对离群值具有天然的抑制作用，能够自动平滑极端的奖励信号。

GMPO 公式

实验表明 GMPO 的重要性采样比率分布更窄，KL 散度增长更可控。在 AIME24、MATH500 等基准上，GMPO-7B 平均超越 GRPO 约 4.1%。

GFPO：对抗思维链注水#

GFPO（Group Filtered Policy Optimization）[16] 针对 GRPO 训练后的一个副作用：Length Hacking。模型倾向于生成极长的思维链，因为更长的尝试次数往往能”撞”对答案获得 reward，导致推理成本飙升。

GFPO 的策略是”多采，少训”：对每个 prompt 过度采样（如 64 或 128 个），然后引入 Token Efficiency（Reward per Token）指标，仅保留既正确又简洁的 top-k 个样本用于梯度更新，将不合格样本的 advantage 设为 0。此外还根据实时通过率动态调整采样规模，将算力集中在难样本上。

GFPO 框架

实验中，GFPO 训练的模型推理长度减少了 46%–71%，准确率与 GRPO 持平甚至略优。核心理念是”在训练时多花算力（多采样），换取推理时的极致高效”。

MaxRL#

MaxRL（Maximum Likelihood Reinforcement Learning）[17] 的出发点与前述方法不同：标准 RL 优化的是期望奖励（即 pass@1），而实际训练中常观察到 pass@1 的提升以 pass@kkk 下降为代价，这未必是最合适的优化目标。与之对比，预训练和 SFT 所采用的最大似然训练优化的是 log⁡pθ(x)\log p_\theta(x)logpθ(x)。

这一区别并非表面上的。作者证明了

log⁡pθ(x)=−∑k=1∞(1−pθ(x))kk,\log p_\theta(x) = -\sum_{k=1}^{\infty}\frac{(1-p_\theta(x))^k}{k},logpθ(x)=−k=1∑∞k(1−pθ(x))k,

即最大似然的梯度是 pass@kkk 梯度的无穷调和混合，而非仅仅 pass@1。标准 RL 只保留了这个展开式的一阶项。

基于此，MaxRL 定义了一族按计算量索引的截断目标：

JMaxRL(T)(x)=−∑k=1T(1−pθ(x))kk,J_{\text{MaxRL}}^{(T)}(x) = -\sum_{k=1}^{T}\frac{(1-p_\theta(x))^k}{k},JMaxRL(T)(x)=−k=1∑Tk(1−pθ(x))k,

其中 T=1T=1T=1 退化为标准 RL，T→∞T\to \inftyT→∞ 则恢复为最大似然。

与这一目标梯度一致的 on-policy 估计器形式很简洁：对每个 prompt 采样 NNN 条 rollout，设其中 KKK 条成功，则 MaxRL 只对成功轨迹的 score function 取平均：

g^N(x)={1K∑i=1Nri∇θlog⁡πθ(yi∣x),K≥1,0,K=0.\hat{g}_N(x) = \begin{cases} \displaystyle \frac{1}{K}\sum_{i=1}^{N} r_i \nabla_\theta \log \pi_\theta(y_i \mid x), & K \ge 1, \\[0.8em] 0, & K = 0. \end{cases}g^N(x)=⎩⎨⎧K1i=1∑Nri∇θlogπθ(yi∣x),0,K≥1,K=0.

该估计器对截断阶数 T=NT=NT=N 的 MaxRL 目标是无偏的。与 REINFORCE 的关键区别在于：增加 rollout 数量不仅降低了估计器方差，同时也使被优化的目标本身更好地逼近最大似然——这是一个双重收益。

将估计器改写为带零均值控制变量的 REINFORCE 形式，可以更清楚地看到权重分配的逻辑。设 r^=K/N\hat r = K/Nr^=K/N 为该 prompt 的成功率，则有效 advantage 正比于

A^iMaxRL∝ri−r^r^.\hat{A}_i^{\text{MaxRL}} \propto \frac{r_i - \hat r}{\hat r}.A^iMaxRL∝r^ri−r^.

这解释了为什么 MaxRL 会将学习信号集中在难题上：当 r^\hat rr^ 很小但非零时，该 prompt 上的成功 rollout 会获得很强的权重；而对于 r^≈1\hat r \approx 1r^≈1 的简单题目，额外的强化信号则很有限。

实验上，MaxRL 在 pass@kkk 指标上优于 GRPO，更好地保持了输出多样性，并在 test-time scaling 效率上取得了显著提升。

从概念上看，MaxRL 将可验证任务上的 RL 重新理解为不可微采样下的近似最大似然训练，这一视角本身也值得关注。

NGRPO：从全错中学习【实测有效】#

NGRPO（Negative-enhanced GRPO）[18] 解决的是 GRPO 在面对同质化错误时的学习停滞问题。当模型生成的一组回复全部错误时，组内归一化后所有 advantage 为零，该提示不贡献梯度。DAPO 的动态采样通过重新采样来规避这个问题，而 NGRPO 提出了另一种思路。

NGRPO 在计算优势时假设组内存在一个虚拟满分样本。具体做法是：在计算均值和标准差时，额外加入一个奖励为 rmax⁡r_{\max}rmax 的虚拟样本。这样即使所有真实回复得分相同（比如全是 0.8 分），因为虚拟满分样本的存在，组均值会略高于 0.8，使所有真实回复的优势变为负数，从而产生”需要改进”的信号。

rewards = [0.8, 0.8, 0.8, 0.8]
augmented = rewards + [1.0]  # 虚拟满分样本
mean = sum(augmented) / len(augmented)  # 0.84
std = sqrt(variance(augmented))          # 0.08
advantage = (r - mean) / std             # 非零！

DPPO#

DPPO（Divergence PPO）[19] 比 DAPO 和 CISPO 更直接地重新审视了信赖域问题。

核心批评是：PPO 基于采样 token 的概率比率进行裁剪，但这可能是实际策略散度的一个较差代理，尤其对于低概率 token。它们的概率可以变化一个数量级，却对完整分布的影响微乎其微。

这一问题在训练/推理框架不匹配时进一步放大：即使参数完全相同，低概率 token 的概率比率在不同框架间也可能高度不稳定，而全变差（TV）等散度度量则稳定得多。

DPPO 因此将基于比率的掩码替换为以估计策略散度（TV 或 KL）定义的信赖域。精确计算词表上的完整散度代价很高，但二元近似（只比较采样 token 在两个策略下的概率）或 top-K 近似在实验中都有不错的效果。

DPPO 的更新为

JDPPO(θ)=E[Mdiv ⁣(D^(πθ,πθold),τ) ρ(θ) A^],J^{\text{DPPO}}(\theta) = \mathbb{E}\left[ M_{\text{div}}\!\left(\widehat{D}(\pi_\theta,\pi_{\theta_{\text{old}}}), \tau\right)\, \rho(\theta)\, \hat{A} \right],JDPPO(θ)=E[Mdiv(D(πθ,πθold),τ)ρ(θ)A^],

其中 MdivM_{\text{div}}Mdiv 掩码掉估计散度超过阈值 τ\tauτ 的更新。

实验中的一个有趣发现是：只有极少数（不到 0.5%）的更新是不稳定性的根源，即负样本将策略推得太远。阻断这些更新就足以稳定训练。

DPPO 因此提出（并给出了一种回答）了一个重要问题：在 LLM 场景下应该如何定义信赖域。

SAPO：软自适应门控#

SAPO（Soft Adaptive Policy Optimization）[20] 针对 GRPO 硬截断（Hard Clipping）的两难：截断过严导致有价值的 off-policy 样本梯度被完全丢弃，截断过松则引入高方差噪声导致训练发散。在 MoE 模型训练中这一问题尤为突出——训练模型和采样模型的专家路由可能不同，导致对数概率差异巨大，极易触发硬截断。

SAPO 用平滑的 Sigmoid 门控函数替代硬性 clip，并引入正向/负向温度参数 (τpos,τneg)(\tau_{\text{pos}}, \tau_{\text{neg}})(τpos,τneg)：对正优势（好回复）允许更大的更新幅度但随偏离程度平滑衰减，对负优势（差回复）施加更严格的约束。

SAPO Sigmoid 门控

SAPO 成功用于训练 Qwen3-VL 系列，解决了 GRPO 在多模态混合数据上易发散的问题，构建了连续的信赖域使梯度更新更加平滑。

ScaleRL#

ScaleRL [21] 的重点不在于提出新的目标函数，而在于确定哪些设计选择在计算规模认真扩大后仍然重要。该论文报告了超过 40 万 GPU 小时的消融实验，更关键的是，通过拟合性能-计算量的 sigmoid 曲线来评估方法，而非仅比较单个训练检查点。

这一框架很有价值，因为它区分了两个常被混淆的量：方法在给定计算预算下的提升速度，以及它最终的饱和水平。一个方法可能在低计算量下表现强劲，却提前进入平台期；另一个方法可能上升较慢，但能达到更好的渐近水平。

主要发现如下：

异步 RL。 ScaleRL 倾向于流水线式异步设计，而非常见的先生成后更新循环。在这一设计中，rollout 持续生成，权重更新即时推送。这主要通过减少空闲时间来提升计算效率，同时保持最终性能持平或更优。

损失类型。 在比较的 off-policy 损失函数中，CISPO 和 GSPO 在渐近性能上优于 DAPO，CISPO 被选为默认方法，因为它兼具强性能和较好的鲁棒性。

FP32 logits。 生成内核和训练内核之间的微小数值不匹配可能显著扭曲重要性采样比率。如 MiniMax 报告 [13] 所提议，将 LM head 以 FP32 计算能大幅缓解这一问题，并在消融中显著提升渐近性能。

损失聚合。 在损失聚合方面，ScaleRL 证实了 Dr. GRPO [11] 和 DAPO [7] 指出的偏差——样本级平均是次优的。他们观察到 prompt 级平均的性能最佳。

零方差过滤。 如果某提示的所有答案全对或全错，则没有学习信号。ScaleRL 不像 DAPO [7] 那样继续采样（在步数上可能是最优的），而是将这些提示排除出优化，加速训练。

不做正样本重采样。 如果某提示的正确率超过 90%，则在后续 epoch 中将其排除。这略微减慢训练速度，但能达到更高的渐近性能。

ScaleRL 的价值在于大规模实验验证，以及对改进曲线形态的澄清——包括早期学习速度和渐近性能两个维度。

GDPO：多目标奖励解耦#

GDPO（Group reward-Decoupled Normalization Policy Optimization）[22] 解决的是多目标奖励场景下的奖励坍塌问题。随着 Agent 任务的复杂化，模型往往需要同时满足多个约束（如”答案正确”、“代码格式规范”、“运行时间短”）。GRPO 的做法是将所有奖励求和 Rtotal=racc+rformat+reffR_{\text{total}} = r_{\text{acc}} + r_{\text{format}} + r_{\text{eff}}Rtotal=racc+rformat+reff 后做组内归一化，但这会导致”答案对但格式错”与”答案错但格式对”得出相似的总分和优势值，模型无法区分哪种行为应被强化。

GDPO 的方案是先对每个子奖励分别在组内归一化，再加权求和：

Ai,total=∑kwk⋅Normalize(ri,k)A_{i, \text{total}} = \sum_{k} w_k \cdot \text{Normalize}(r_{i, k})Ai,total=k∑wk⋅Normalize(ri,k)

之后引入批次级缩放因子确保优势值在不同 batch 间保持稳定。

GDPO 框架

在 Coding 和 Tool-use 任务中，GDPO 能够同时提升代码通过率和格式遵循率，而 GRPO 往往顾此失彼。

DART：解耦推理与工具调用#

DART（Disentangled Action-Reasoning Tuning）是 Yu Li 等人在 Reasoning and Tool-use Compete in Agentic RL [23] 中提出的方法，针对的是训练模型同时推理和使用工具时的梯度冲突。推理 token（思维链）和动作 token（工具调用）的优化目标存在根本差异，在共享参数上做统一更新会产生干扰。

DART 的方案是引入两个独立的 LoRA 模块：Reasoning Adapter 负责更新推理相关的参数，Action Adapter 负责更新工具调用相关的参数。训练时根据 token 类型选择性地应用不同的 adapter：

# 根据 token 类型路由到不同 LoRA
delta_reasoning = lora_reasoning(hidden_states)
delta_action = lora_action(hidden_states)
output = hidden_states + delta_reasoning * mask_thinking + delta_action * mask_action

在损失层面也做了加权分离（如 0.3 × reasoning_loss + 0.7 × tool_loss），使两类能力可以以不同速率学习。

总结#

下表总结了各方法间的主要差异：

方法	基线/优势	裁剪	掩码	损失聚合	主要贡献
REINFORCE	EMA 或批次平均奖励	无	无	样本平均	建立策略梯度
PPO	GAE + critic	对称 IS	Msym(A^t,ρt,0.2)M_\text{sym}(\hat{A}_t, \rho_t, 0.2)Msym(A^t,ρt,0.2)	样本平均	稳定，样本效率更高
GRPO	(r−μG)/σG(r-\mu_G)/\sigma_G(r−μG)/σG	对称 IS	Msym(A^t,ρt,0.2)M_\text{sym}(\hat{A}_t, \rho_t, 0.2)Msym(A^t,ρt,0.2)	长度归一化†^\dagger†	去掉 critic，更低内存
RLOO	Leave-one-out 均值	无	无	样本平均	无 critic 的方差缩减
Dr. GRPO	r−μGr - \mu_Gr−μG	对称 IS	Msym(A^t,ρt,0.2)M_\text{sym}(\hat{A}_t, \rho_t, 0.2)Msym(A^t,ρt,0.2)	固定常数归一化‡^\ddagger‡	去除长度偏差和标准差加权
DAPO	(r−μG)/σG(r-\mu_G)/\sigma_G(r−μG)/σG	非对称 IS	Masym(A^t,ρt,0.2,0.28)M_\text{asym}(\hat{A}_t, \rho_t, 0.2, 0.28)Masym(A^t,ρt,0.2,0.28)	Token 平均	给低概率 token 更多增长空间
VAPO	Decoupled-GAE + critic	非对称 IS	PPO 风格	Token 平均	精心设计的 critic 回归
CISPO	组内 (r−μG)/σG(r-\mu_G)/\sigma_G(r−μG)/σG	上界 IS	无	Token 平均	不掩码梯度，只裁剪权重
GSPO	(r−μG)/σG(r-\mu_G)/\sigma_G(r−μG)/σG	序列级 IS	序列级	序列平均	序列级统一优化
GMPO	几何平均	对称 IS	PPO 风格	Token 平均	对离群值鲁棒的统计量
GFPO	(r−μG)/σG(r-\mu_G)/\sigma_G(r−μG)/σG	对称 IS	效率过滤	样本平均	抑制 Length Hacking
MaxRL	(ri−r^)/(N⋅r^)(r_i - \hat{r})/(N\cdot \hat{r})(ri−r^)/(N⋅r^)	无	无	样本平均	在 RL 和 MLE 间插值
NGRPO	含虚拟满分样本的归一化	对称 IS	PPO 风格	样本平均	从全错组中提取梯度
DPPO	组内 (r−μ)/σ(r-\mu)/\sigma(r−μ)/σ	对称 DV	Mdiv(A^t,υt,0.15)M_\text{div}(\hat{A}_t, \upsilon_t, 0.15)Mdiv(A^t,υt,0.15)	样本平均	用散度信赖域适配 LLM
SAPO	(r−μG)/σG(r-\mu_G)/\sigma_G(r−μG)/σG	Sigmoid 门控	无（连续权重）	Token 平均	软信任域，MoE 友好
ScaleRL	(r−μB)/σB(r-\mu_B)/\sigma_B(r−μB)/σB	上界 IS	无	Prompt 平均	大规模验证与 scaling law
GDPO	分奖励独立归一化	对称 IS	PPO 风格	样本平均	多目标奖励解耦
DART	GRPO 风格	对称 IS	PPO 风格	加权 Token 平均	推理与工具调用解耦

†^\dagger† 不同实现可能有所差异，例如 Huggingface TRL

‡^\ddagger‡ 使用固定常数作为分母

其中

ρt(θ)=πθ(a∣s)πθold(a∣s)υt(θ)=πθ(a∣s)−πθold(a∣s)Msym(A^t,ρt,ϵ)={0if (A^t>0∧ρt>1+ϵ)∨(A^t<0∧ρt<1−ϵ)1otherwiseMasym(A^t,ρt,ϵl,ϵh)={0if (A^t>0∧ρt>1+ϵh)∨(A^t<0∧ρt<1−ϵl)1otherwiseMdiv(A^t,υt,δ)={0if (A^t>0∧υt>δ)∨(A^t<0∧υt<δ)1otherwise\begin{align*} \rho_t(\theta) &= \frac{\pi_\theta(a|s)}{\pi_{\theta_{\text{old}}}(a|s)} \\ \upsilon_t(\theta) &= \pi_\theta(a|s) - \pi_{\theta_{\text{old}}}(a|s) \\ M_\text{sym}(\hat{A}_t, \rho_t, \epsilon) &= \begin{cases} 0 & \text{if } (\hat{A}_t > 0 \land \rho_t > 1 + \epsilon) \lor (\hat{A}_t < 0 \land \rho_t < 1 - \epsilon) \\ 1 & \text{otherwise} \end{cases} \\ M_\text{asym}(\hat{A}_t, \rho_t, \epsilon_l, \epsilon_h) &= \begin{cases} 0 & \text{if } (\hat{A}_t > 0 \land \rho_t > 1 + \epsilon_h) \lor (\hat{A}_t < 0 \land \rho_t < 1 - \epsilon_l) \\ 1 & \text{otherwise} \end{cases} \\ M_\text{div}(\hat{A}_t, \upsilon_t, \delta) &= \begin{cases} 0 & \text{if } (\hat{A}_t > 0 \land \upsilon_t > \delta) \lor (\hat{A}_t < 0 \land \upsilon_t < \delta) \\ 1 & \text{otherwise} \end{cases} \end{align*}ρt(θ)υt(θ)Msym(A^t,ρt,ϵ)Masym(A^t,ρt,ϵl,ϵh)Mdiv(A^t,υt,δ)=πθold(a∣s)πθ(a∣s)=πθ(a∣s)−πθold(a∣s)={01if (A^t>0∧ρt>1+ϵ)∨(A^t<0∧ρt<1−ϵ)otherwise={01if (A^t>0∧ρt>1+ϵh)∨(A^t<0∧ρt<1−ϵl)otherwise={01if (A^t>0∧υt>δ)∨(A^t<0∧υt<δ)otherwise

纵观这些方法，有几个反复出现的规律：

Critic 在多数场景下不再必要。 PPO 之后的大多数方法发现，更简单的基线（组均值、leave-one-out、贪心 rollout）能匹配或超过学习得到的价值函数，同时节省约 50% 的内存。LLM 微调场景中模型从强大的预训练检查点出发（而非随机初始化），这使得 PPO 的方差缩减机制在多数情况下冗余。例外是 VAPO，它表明在极复杂推理任务上，精心设计的 critic 仍能提供更精确的指导——关键不在于要不要 critic，而在于如何设计好它。

标准差归一化往往有害。 Dr. GRPO 和 MaxRL 都表明，优势除以 σ\sigmaσ 会给接近解决的问题赋予过高权重。ScaleRL 的消融证实，带标准差归一化的 DAPO 相比 CISPO 和 GSPO [14] 达到了显著更低的渐近性能。

损失聚合并非细枝末节。 Dr. GRPO 和 DAPO 表明，序列级奖励与样本级平均结合会扭曲逐 token 的学习信号。损失的归约方式是方法的关键组成部分，错误的选择可能引入隐蔽的偏差。GSPO 则提出了另一种思路：既然奖励就是序列级的，不如把优化也统一到序列级。

信赖域是值得优化的切入点。 PPO 对信赖域的定义（ϵ=0.2\epsilon = 0.2ϵ=0.2）选择得相当好，在不同模型和任务间表现稳健。但近期多种方法以信赖域为改进方向并取得了提升：DAPO 做非对称放松，CISPO 裁剪权重而非掩码梯度，DPPO 则认为基于采样 token 比率的约束根本不是正确的约束对象，SAPO 用 Sigmoid 门控替代硬截断。该领域尚未就信赖域的定义达成共识，但这方面的进一步研究有望带来持续改进。

从废样本中提取信号。 DAPO 的动态采样和 NGRPO 的虚拟满分样本都在解决同一个问题：如何让全对/全错的组也贡献有效梯度。GFPO 则从另一个角度出发，通过效率过滤抑制 Length Hacking，确保训练信号集中在高质量样本上。

初步的最佳实践正在形成。 目前最强的大规模证据指向：无 critic 训练、token 感知或 prompt 感知的损失聚合、更软或更有原则的信赖域处理，以及对课程学习和计算分配越来越多的关注 [13], [19], [21]。虽然这是进步，但一个新方法或新细节的出现就可能迅速改变格局。

开放问题#

尽管进展迅速，若干基本挑战仍然存在。本节的参考文献不完整，如有遗漏欢迎补充。

信用分配。 [24], [25], [26] 当前基于结果的方法对回复中的所有 token 赋予基本相同的奖励。这出人意料地有效且易于实现，但显然效率不高。导致推理失败的那个 token 与周围的模板性 token 接收到相同的信号。过程奖励模型、步级验证器、基于搜索的方法和分支敏感的训练目标都在尝试解决这一问题，但尚无方法成为标准方案。

样本效率。 [27] RL 中的信息增益仅为一个 bit（正确/错误）。当前多数方案依赖每个提示多次 rollout（通常 8 到 64 次）来构建有用的相对基线。即使有自动验证器这也很昂贵，而当验证代价高或需要部分人工时就更甚。更好地复用失败样本、更好的离线到在线混合、或更好的提示选择策略，都有可能显著降低这一成本。

极难问题。 [28], [29] 如果模型对某个提示从未产生正确 rollout，则这里所有方法都不提供梯度。课程学习在实践中有帮助，但只是权宜之计。从部分正确轨迹中提取信号，或将搜索与 RL 结合的更强方法，仍然是重要的研究方向（与信用分配相关）。

向数学和代码之外拓展。 [30], [31] 近期几乎所有进展都来自验证廉价且无歧义的领域（数学和代码）。将这些方法扩展到噪声奖励、延迟奖励、主观评估或多轮交互的场景仍然困难。

实验可靠性。 [32], [33] 可能是最被低估的开放问题：该领域的许多证据仍然是经验性的、范围较窄且复现成本高。很多论文只测试了一个模型系列、一种验证器配置、一个数据集组合和一个计算预算。正如 ScaleRL 所明确指出的，一项干预可能改变早期学习速度、渐近性能，或两者兼有，而这两者不可互换。因此我们实际了解的比有时看起来的要少。有些方法可能是稳健的算法改进，而另一些可能主要适用于特定的模型、奖励设计或训练制度。两者都有用，但我们需要了解它们的局限性。

这些开放问题指向一个更广泛的结论：推理 LLM 的 RL 不再受限于缺乏可行的算法——我们现在有好几个。更难的问题在于效率、鲁棒性、通用性，以及理解哪些经验性改进真正能经受规模考验并跨场景迁移。

参考文献#

Footnotes#

LLM 在应用 RL 时已经过充分训练，不同于传统 RL 智能体通常从随机初始化开始。虽然动作空间（词表）大得多，但概率质量集中在少数合理 token 上。 ↩

[1] Ouyang, L., Wu, J., Jiang, X., et al., “Training Language Models to Follow Instructions with Human Feedback,” in Advances in Neural Information Processing Systems, 2022. doi: 10.48550/arXiv.2203.02155.

[2] OpenAI, “OpenAI o1 System Card.” 2024. doi: 10.48550/arXiv.2412.16720.

[3] DeepSeek-AI, Guo, D., Yang, D., et al., “DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning,”Nature, vol. 645, pp. 633–638, 2025, doi: 10.1038/s41586-025-09422-z.

[4] Schulman, J., Wolski, F., Dhariwal, P., et al., “Proximal Policy Optimization Algorithms.” 2017. doi: 10.48550/arXiv.1707.06347.

[5] Williams, R. J., “Simple Statistical Gradient-Following Algorithms for Connectionist Reinforcement Learning,”Machine Learning, vol. 8, pp. 229–256, 1992, doi: 10.1007/BF00992696.

[6] Schulman, J., Levine, S., Abbeel, P., et al., “Trust Region Policy Optimization,” in Proceedings of the 32nd International Conference on Machine Learning, in Proceedings of Machine Learning Research, vol. 37. Lille, France: PMLR, 2015, pp. 1889–1897. [Online]. Available: https://proceedings.mlr.press/v37/schulman15.html

[7] Yu, Q., Zhang, Z., Zhu, R., et al., “DAPO: An Open-Source LLM Reinforcement Learning System at Scale,” in Advances in Neural Information Processing Systems, 2025. doi: 10.48550/arXiv.2503.14476.

[8] Shao, Z., Wang, P., Zhu, Q., et al., “DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models.” 2024. doi: 10.48550/arXiv.2402.03300.

[9] Ahmadian, A., Cremer, C., Gallé, M., et al., “Back to Basics: Revisiting REINFORCE-Style Optimization for Learning from Human Feedback in LLMs,” in Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), Bangkok, Thailand: Association for Computational Linguistics, Aug. 2024, pp. 12248–12267. doi: 10.18653/v1/2024.acl-long.662.

[10] Hu, J., Zhang, Y., Han, Q., et al., “Open-Reasoner-Zero: An Open Source Approach to Scaling Up Reinforcement Learning on the Base Model,” in Advances in Neural Information Processing Systems, 2025. doi: 10.48550/arXiv.2503.24290.

[11] Liu, Z., Chen, C., Li, W., et al., “Understanding R1-Zero-Like Training: A Critical Perspective,” in Proceedings of the Conference on Language Modeling, 2025. doi: 10.48550/arXiv.2503.20783.

[12] Yue, Y., Yuan, Y., Yu, Q., et al., “VAPO: Efficient and Reliable Reinforcement Learning for Advanced Reasoning Tasks.” 2025. doi: 10.48550/arXiv.2504.05118.

[13] MiniMax, Chen, A., Li, A., et al., “MiniMax-M1: Scaling Test-Time Compute Efficiently with Lightning Attention.” 2025. doi: 10.48550/arXiv.2506.13585.

[14] Zheng, C., Liu, S., Li, M., et al., “Group Sequence Policy Optimization.” 2025. doi: 10.48550/arXiv.2507.18071.

[15] Zhao, Y., Liu, Y., Liu, J., et al., “Geometric-Mean Policy Optimization,” in International Conference on Learning Representations, 2026. doi: 10.48550/arXiv.2507.20673.

[16] Shrivastava, V., Awadallah, A., Balachandran, V., et al., “Sample More to Think Less: Group Filtered Policy Optimization for Concise Reasoning.” 2025. doi: 10.48550/arXiv.2508.09726.

[17] Tajwar, F., Zeng, G., Zhou, Y., et al., “Maximum Likelihood Reinforcement Learning.” 2026. doi: 10.48550/arXiv.2602.02710.

[18] Nan, G., Chen, S., Huang, J., et al., “NGRPO: Negative-Enhanced Group Relative Policy Optimization.” 2025. doi: 10.48550/arXiv.2509.18851.

[19] Qi, P., Zhou, X., Liu, Z., et al., “Rethinking the Trust Region in LLM Reinforcement Learning.” 2026. doi: 10.48550/arXiv.2602.04879.

[20] Gao, C., Zheng, C., Chen, X.-H., et al., “Soft Adaptive Policy Optimization.” 2025. doi: 10.48550/arXiv.2511.20347.

[21] Khatri, D., Madaan, L., Tiwari, R., et al., “The Art of Scaling Reinforcement Learning Compute for LLMs.” 2025. doi: 10.48550/arXiv.2510.13786.

[22] Liu, S.-Y., Dong, X., Lu, X., et al., “GDPO: Group Reward-Decoupled Normalization Policy Optimization for Multi-Reward RL Optimization.” 2026. doi: 10.48550/arXiv.2601.05242.

[23] Li, Y., Yi, M., Li, X., et al., “Reasoning and Tool-Use Compete in Agentic RL: From Quantifying Interference to Disentangled Tuning.” 2026. doi: 10.48550/arXiv.2602.00994.

[24] Zhang, Z., Zheng, C., Wu, Y., et al., “The Lessons of Developing Process Reward Models in Mathematical Reasoning,” in Findings of the Association for Computational Linguistics: ACL 2025, Vienna, Austria: Association for Computational Linguistics, Jul. 2025, pp. 10495–10516. doi: 10.18653/v1/2025.findings-acl.547.

[25] She, S., Liu, J., Liu, Y., et al., “R-PRM: Reasoning-Driven Process Reward Modeling,” in Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, Suzhou, China: Association for Computational Linguistics, Nov. 2025, pp. 13438–13451. doi: 10.18653/v1/2025.emnlp-main.679.

[26] Sharma, R., Chen, W., Provenzano, N., et al., “PRISM: Pushing the Frontier of Deep Think via Process Reward Model-Guided Inference.” 2026. doi: 10.48550/arXiv.2603.02479.

[27] Mao, Y., Qu, Y., Wang, Q., et al., “Dynamics-Predictive Sampling for Active RL Finetuning of Large Reasoning Models,” in International Conference on Learning Representations, 2026. doi: 10.48550/arXiv.2603.10887.

[28] Setlur, A., Wang, Z., Cohen, A., et al., “Reuse Your FLOPs: Scaling RL on Hard Problems by Conditioning on Very Off-Policy Prefixes.” 2026. doi: 10.48550/arXiv.2601.18795.

[29] Qu, Y., Setlur, A., Smith, V., et al., “POPE: Learning to Reason on Hard Problems via Privileged On-Policy Exploration.” 2026. doi: 10.48550/arXiv.2601.18779.

[30] Zhao, X., Kang, Z., Feng, A., et al., “Learning to Reason without External Rewards,” in International Conference on Learning Representations, 2026. doi: 10.48550/arXiv.2505.19590.

[31] Lu, X., Acuna, D., Jung, J., et al., “Golden Goose: A Simple Trick to Synthesize Unlimited RLVR Tasks from Unverifiable Internet Text.” 2026. doi: 10.48550/arXiv.2601.22975.

[32] Hu, C., Zhu, Y., Kellermann, A., et al., “Breaking Barriers: Do Reinforcement Post-Training Gains Transfer to Unseen Domains?,” in International Conference on Learning Representations, 2026. doi: 10.48550/arXiv.2506.19733.

[33] Yue, Y., Chen, Z., Lu, R., et al., “Does Reinforcement Learning Really Incentivize Reasoning Capacity in LLMs Beyond the Base Model?,” in Advances in Neural Information Processing Systems, 2025. doi: 10.48550/arXiv.2504.13837.

Linux配置

Fri, 27 Dec 2024 00:00:00 GMT

开发环境#

Docker#

远程连接#

vscode连接服务器#

首先登录虚拟机，在虚拟机中安装服务openssh-server：

sudo apt install openssh-server

查看本机的 IP 地址ifconfig。

回到家目录，观察有没有.ssh文件夹，没有直接mkdir .ssh新建一个就行了。

在.ssh文件夹中touch authorized_keys 新建一个authorized_keys文件，这个文件用来保存之后的ssh公钥。

如果Windows没有公私钥，打开powershell 使用ssh-keygen生成密钥

复制Windows下的id_rsa.pub 密钥（一般在user/xxx/.ssh目录下），粘贴到authorized_keys

使用vscode Remote - SSH插件连接即可

Git

Fri, 08 Dec 2023 00:00:00 GMT

LFS安装#

https://github.com/git-lfs/git-lfs/blob/main/INSTALLING.md

curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash
apt-get install git-lfs

初始化#

设置用户名和密码

git config --global user.name "xwysyy"
git config --global user.email ""

注意，可能存在推送或者拉取失败的情况，需要设置端口代理，这里用的是v2rayN，转发端口为1080

# 配置代理
git config --global http.proxy 127.0.0.1:10808
git config --global https.proxy 127.0.0.1:10808
# 查看代理
git config --global --get http.proxy
git config --global --get https.proxy
# 取消代理
git config --global --unset http.proxy
git config --global --unset https.proxy

连接远程仓库#

git remote add origin <....git>

查看是否连接

git remote -v

git pull#

# 拉取默认分支
git pull
# 或使用带参数 pull， 拉取指定分支
git pull origin master

git add#

将文件添加到暂存区

git add <file_name>

将所有修改过的文件添加到暂存区

git add .

git commit#

提交暂存区的文件到本地仓库

git commit -m commit_message

git push#

 git push
 # git push origin master

清除cache#

git rm -r --cached .

清除git仓库的所有提交记录#

创建新分支

git checkout --orphan newBranch

添加所有文件(除了.gitignore中声明排除的)

git add -A

提交跟踪过的文件（Commit the changes）

git commit -am init

删除master分支

git branch -D master

重命名当前分支为master

git branch -m master

重新指定远端

git remote add origin "xxx.git"

已经有了就是git remote set-url origin ..
强制提交到远程master分支

git push -f origin master

git回退到某个版本#

git reset --hard <commit>
git push -f -u origin master

LaTeX

Fri, 08 Dec 2023 00:00:00 GMT

转自https://github.com/1024th

基础内容#

上标、下标及积分等#

^ 表示上标，_ 表示下标。如果上下标的内容多于一个字符，需要用 {} 将这些内容括成一个整体。上下标可以嵌套，也可以同时使用。

上标

a^2

a2{\displaystyle a^{2} }a2

下标

a_2

a2{\displaystyle a_{2} }a2

组合

a^{2+2}

a2+2{\displaystyle a^{2+2} }a2+2

a_{i,j}

ai,j{\displaystyle a_{i,j} }ai,j

结合上下标

x_2^3

x23{\displaystyle x_{2}^{3} }x23

前置上下标

{}_1^2\!X_3^4

12 ⁣X34{\displaystyle {}_{1}^{2}\!X_{3}^{4} }12X34

导数（HTML）

x'

x′{\displaystyle x'}x′

导数（PNG）

x^\prime

x′{\displaystyle x^{\prime} }x′

导数（错误）

x\prime

x′{\displaystyle x\prime}x′

导数点

\dot{x}

x˙{\displaystyle {\dot {x} }}x˙

\ddot{y}

y¨{\displaystyle {\ddot {y} }}y¨

向量

\vec{c}（只有一个字母）

c⃗{\displaystyle {\vec {c} }}c

\overleftarrow{a b}

ab←{\displaystyle {\overleftarrow {ab} }}ab

\overrightarrow{c d}

cd→{\displaystyle {\overrightarrow {cd} }}cd

\overleftrightarrow{a b}

ab↔{\displaystyle {\overleftrightarrow {ab} }}ab

\widehat{e f g}

efg^{\displaystyle {\widehat {efg} }}efg

上弧

（注：正确应该用 \overarc，但在这里行不通。要用建议的语法作为解决办法。）（使用 \ overarc 时需要引入 {arcs} 包。）

\overset{\frown} {AB}

AB⌢{\displaystyle {\overset {\frown}{AB} }}AB⌢

上划线

\overline{h i j}

hij‾{\displaystyle {\overline {hij} }}hij

下划线

\underline{k l m}

klm‾{\displaystyle {\underline {klm} }}klm

上括号

\overbrace{1+2+\cdots+100}

1+2+⋯+100⏞{\displaystyle \overbrace {1+2+\cdots +100} }1+2+⋯+100

\begin{matrix} 5050 \\ \overbrace{ 1+2+\cdots+100 } \end{matrix}

50501+2+⋯+100⏞{\displaystyle {\begin{matrix}5050\\\overbrace {1+2+\cdots +100} \end{matrix} }}50501+2+⋯+100

下括号

\underbrace{a+b+\cdots+z}

a+b+⋯+z⏟{\displaystyle \underbrace {a+b+\cdots +z} }a+b+⋯+z

\begin{matrix} \underbrace{ a+b+\cdots+z } \\ 26 \end{matrix}

a+b+⋯+z⏟26{\displaystyle {\begin{matrix}\underbrace {a+b+\cdots +z} \\26\end{matrix} }}a+b+⋯+z26

求和（累加）

\sum_{k=1}^N k^2

∑k=1Nk2{\displaystyle \sum _{k=1}^{N}k^{2} }k=1∑Nk2

\begin{matrix} \sum_{k=1}^N k^2 \end{matrix}

∑k=1Nk2{\displaystyle {\begin{matrix}\sum _{k=1}^{N}k^{2}\end{matrix} }}∑k=1Nk2

求积（累乘）

\prod_{i=1}^N x_i

∏i=1Nxi{\displaystyle \prod _{i=1}^{N}x_{i} }i=1∏Nxi

\begin{matrix} \prod_{i=1}^N x_i \end{matrix}

∏i=1Nxi{\displaystyle {\begin{matrix}\prod _{i=1}^{N}x_{i}\end{matrix} }}∏i=1Nxi

上积

\coprod_{i=1}^N x_i

∐i=1Nxi{\displaystyle \coprod _{i=1}^{N}x_{i} }i=1∐Nxi

\begin{matrix} \coprod_{i=1}^N x_i \end{matrix}

∐i=1Nxi{\displaystyle {\begin{matrix}\coprod _{i=1}^{N}x_{i}\end{matrix} }}∐i=1Nxi

极限

\lim_{n \to \infty}x_n

lim⁡n→∞xn{\displaystyle \lim _{n\to \infty}x_{n} }n→∞limxn

\begin{matrix} \lim_{n \to \infty}x_n \end{matrix}

lim⁡n→∞xn{\displaystyle {\begin{matrix}\lim _{n\to \infty }x_{n}\end{matrix} }}limn→∞xn

积分

\int_{-N}^{N} e^x\, {\rm d}x

∫−NNex dx{\displaystyle \int _{-N}^{N}e^{x}\,{\rm d} x}∫−NNexdx

本例中 \, 和 {\rm d} 部分可省略，但建议加入，能使式子更美观。{\rm d}可以用\mathrm{d}等价替换。

\begin{matrix} \int_{-N}^{N} e^x\, \mathrm{d}x \end{matrix}（矩阵中积分符号变小）

∫−NNex dx{\displaystyle {\begin{matrix}\int _{-N}^{N}e^{x}\,\mathrm {d} x\end{matrix} }}∫−NNexdx

双重积分

\iint_{D}^{W} \, \mathrm{d}x\,\mathrm{d}y

∬DW dx dy{\displaystyle \iint _{D}^{W}\,\mathrm {d} x\,\mathrm {d} y}∬DWdxdy

三重积分

\iiint_{E}^{V} \, \mathrm{d}x\,\mathrm{d}y\,\mathrm{d}z

∭EV dx dy dz{\displaystyle \iiint _{E}^{V}\,\mathrm {d} x\,\mathrm {d} y\,\mathrm {d} z}∭EVdxdydz

闭合的曲线、曲面积分

\oint_{C} x^3\, \mathrm{d}x + 4y^2\, \mathrm{d}y

∮Cx3 dx+4y2 dy{\displaystyle \oint _{C}x^{3}\,\mathrm {d} x+4y^{2}\,\mathrm {d} y}∮Cx3dx+4y2dy

交集

\bigcap_1^{n} p

⋂1np{\displaystyle \bigcap _{1}^{n}p}1⋂np

并集

\bigcup_1^{k} p

⋃1kp{\displaystyle \bigcup _{1}^{k}p}1⋃kp

分数#

通常使用 \frac {分子} {分母} 命令产生一个分数，分数可嵌套。便捷情况可直接输入 \frac ab 来快速生成一个 ab\frac abba 。如果分式很复杂，亦可使用 分子 \over 分母 命令，此时分数仅有一层。

功能 | 语法 | 效果

分数

\frac{2}{4}=0.5

24=0.5{\displaystyle {\frac {2}{4} }=0.5}42=0.5

小型分数

\tfrac{2}{4} = 0.5

24=0.5{\displaystyle {\tfrac {2}{4} }=0.5}42=0.5

连分式（大型嵌套分式）

\cfrac{2}{c + \cfrac{2}{d + \cfrac{2}{4} }} = a

2c+2d+24=a{\displaystyle {\cfrac {2}{c+{\cfrac {2}{d+{\cfrac {2}{4} }} }} }=a}c+d+4222=a

大型不嵌套分式

\dfrac{2}{4} = 0.5 \qquad \dfrac{2}{c + \dfrac{2}{d + \dfrac{2}{4} }} = a

24=0.52c+2d+24=a{\displaystyle {\dfrac {2}{4} }=0.5\qquad {\dfrac {2}{c+{\dfrac {2}{d+{\dfrac {2}{4} }} }} }=a}42=0.5c+d+4222=a

二项式系数

\dbinom{n}{r}=\binom{n}{n-r}=\mathrm{C}_n^r=\mathrm{C}_n^{n-r}

(nr)=(nn−r)=Cnr=Cnn−r{\displaystyle {\dbinom {n}{r} }={\binom {n}{n-r} }=\mathrm {C} _{n}^{r}=\mathrm {C} _{n}^{n-r} }(rn)=(n−rn)=Cnr=Cnn−r

小型二项式系数

\tbinom{n}{r}=\tbinom{n}{n-r}=\mathrm{C}_n^r=\mathrm{C}_n^{n-r}

(nr)=(nn−r)=Cnr=Cnn−r{\displaystyle {\tbinom {n}{r} }={\tbinom {n}{n-r} }=\mathrm {C} _{n}^{r}=\mathrm {C} _{n}^{n-r} }(rn)=(n−rn)=Cnr=Cnn−r

大型二项式系数

\binom{n}{r}=\dbinom{n}{n-r}=\mathrm{C}_n^r=\mathrm{C}_n^{n-r}

(nr)=(nn−r)=Cnr=Cnn−r{\displaystyle {\binom {n}{r} }={\dbinom {n}{n-r} }=\mathrm {C} _{n}^{r}=\mathrm {C} _{n}^{n-r} }(rn)=(n−rn)=Cnr=Cnn−r

在以 e 为底的指数函数、极限和积分中尽量不要使用 \frac 符号：它会使整段函数看起来很怪，而且可能产生歧义。也正是因此它在专业数学排版中几乎从不出现。横着写这些分式，中间使用斜线间隔 /（用斜线代替分数线）。

例子：

\begin{array}{cc}
\mathrm{Bad} & \mathrm{Better} \\
\hline \\
e^{i\frac{\pi}2} \quad e^{\frac{i\pi}2}& e^{i\pi/2} \\
\int_{-\frac\pi2}^\frac\pi2 \sin x\,dx & \int_{-\pi/2}^{\pi/2}\sin x\,dx \\
\end{array}

显示：

BadBettereiπ2eiπ2eiπ/2∫−π2π2sin⁡x dx∫−π/2π/2sin⁡x dx\begin{array}{cc} \mathrm{Bad} & \mathrm{Better} \\ \hline \\ e^{i\frac{\pi}2} \quad e^{\frac{i\pi}2}& e^{i\pi/2} \\ \int_{-\frac\pi2}^\frac\pi2 \sin x\,dx & \int_{-\pi/2}^{\pi/2}\sin x\,dx \\ \end{array}Badei2πe2iπ∫−2π2πsinxdxBettereiπ/2∫−π/2π/2sinxdx

括号#

()、[] 和 | 表示符号本身，使用 \{\} 来表示 {} 。

功能 | 语法 | 显示

短括号

\frac{1}{2}

(12){\displaystyle ({\frac {1}{2} })}(21)

长括号

\left(\frac{1}{2} \right

(12){\displaystyle \left({\frac {1}{2} }\right)}(21)

使用 \left 和 \right 来创建自动匹配高度的 (圆括号)，[方括号] 和 {花括号} 。

功能 | 语法 | 显示

圆括号，小括号

\left( \frac{a}{b} \right)

(ab){\displaystyle \left( {\frac {a}{b} }\right )}(ba)

花括号，大括号

\left{ \frac{a}{b} \right}

{ab}{\displaystyle \left\{ {\frac {a}{b} }\right\} }{ba}

角括号

\left \langle \frac{a}{b} \right \rangle

⟨ab⟩{\displaystyle \left\langle {\frac {a}{b} }\right\rangle }⟨ba⟩

单竖线，绝对值

\left| \frac{a}{b} \right|

∣ab∣{\displaystyle \left| \frac{a}{b} \right|}ba

双竖线，范

\left \| \frac{a}{b} \right \|

∥ab∥{\displaystyle \left\|{\frac {a}{b} }\right\|}ba

取整函数

\left \lfloor \frac{a}{b} \right \rfloor

⌊ab⌋{\displaystyle \left\lfloor {\frac {a}{b} }\right\rfloor }⌊ba⌋

取顶函数

\left \lceil \frac{c}{d} \right \rceil

⌈cd⌉{\displaystyle \left\lceil {\frac {c}{d} }\right\rceil }⌈dc⌉

斜线与反斜线

\left / \frac{a}{b} \right \backslash

/ab\{\displaystyle \left/{\frac {a}{b} }\right\backslash }/ba\

上下箭头

\left \uparrow \frac{a}{b} \right \downarrow

↑ab↓{\displaystyle \left\uparrow {\frac {a}{b} }\right\downarrow }⏐↑ba↓⏐

\left \Uparrow \frac{a}{b} \right \Downarrow

⇑ab⇓{\displaystyle \left\Uparrow {\frac {a}{b} }\right\Downarrow }‖⇑ba⇓‖

\left \updownarrow \frac{a}{b} \right \Updownarrow

↕ab⇕{\displaystyle \left\updownarrow {\frac {a}{b} }\right\Updownarrow }↓↑ba⇓⇑

混合括号

\left[ 0,1 \right)

[0,1){\displaystyle \left[0,1\right)}[0,1)

\left \langle \psi \right |

⟨ψ∣\left \langle \psi \right |⟨ψ∣

如果括号只有一边，要用 \left. 或 \right. 匹配另一边。

单左括号

\left \{\frac{a}{b} \right.

{ab{\displaystyle \left\{ {\frac {a}{b} }\right.}{ba

单右括号

\left. \frac{a}{b} \right \}

ab}{\displaystyle \left.{\frac {a}{b} }\right\} }ba}

备注：

可以使用 \big, \Big, \bigg, \Bigg 控制括号的大小，比如代码

\Bigg ( \bigg [ \Big \{ \big \langle \left | \| \frac{a}{b} \| \right | \big \rangle \Big \} \bigg ] \Bigg )

显示︰

([{⟨∣∥ab∥∣⟩}])\Bigg ( \bigg [ \Big \{ \big \langle \left | \| \frac{a}{b} \| \right | \big \rangle \Big \} \bigg ] \Bigg )([{⟨∥ba∥⟩}])

空格#

注意 TeX 能够自动处理大多数的空格，但是您有时候需要自己来控制。

功能 | 语法 | 显示 | 宽度

2 个 quad 空格#

\alpha\qquad\beta

αβ{\displaystyle \alpha \qquad \beta}αβ

mm{\displaystyle mm}mm

quad 空格#

\alpha\quad\beta

αβ{\displaystyle \alpha \quad \beta}αβ

m{\displaystyle m}m

大空格#

\alpha\ \beta

α β{\displaystyle \alpha \ \beta}α β

m3{\displaystyle {\frac{m}{3} }}3m

中等空格#

\alpha\;\beta

α β{\displaystyle \alpha \;\beta}αβ

2m7{\displaystyle {\frac {2m}{7} }}72m

小空格#

\alpha\,\beta

α β{\displaystyle \alpha \,\beta}αβ

m6{\displaystyle {\frac {m}{6} }}6m

没有空格#

\alpha\beta

αβ{\displaystyle \alpha \beta }αβ

0{\displaystyle 0}0

紧贴#

\alpha\!\beta

α ⁣β{\displaystyle \alpha \!\beta}αβ

−m6{\displaystyle -{\frac {m}{6} }}−6m

函数、符号及特殊字符#

声调 / 变音符号#

\dot{a}, \ddot{a}, \acute{a}, \grave{a}

a˙,a¨,aˊ,aˋ{\displaystyle {\dot {a} },{\ddot {a} },{\acute {a} },{\grave {a} }}a˙,a¨,aˊ,aˋ

\check{a}, \breve{a}, \tilde{a}, \bar{a}

aˇ,a˘,a~,aˉ{\displaystyle {\check {a} },{\breve {a} },{\tilde {a} },{\bar {a} }}aˇ,a˘,a~,aˉ

\hat{a}, \widehat{a}, \vec{a}

a^,a^,a⃗{\displaystyle {\hat {a} },{\widehat {a} },{\vec {a} }}a^,a,a

标准函数#

指数

\exp_a b = a^b, \exp b = e^b, 10^m

exp⁡ab=ab,exp⁡b=eb,10m{\displaystyle \exp _{a}b=a^{b},\exp b=e^{b},10^{m} }expab=ab,expb=eb,10m

对数

\ln c, \lg d = \log e, \log_{10} f

ln⁡c,lg⁡d=log⁡e,log⁡10f{\displaystyle \ln c,\lg d=\log e,\log _{10}f}lnc,lgd=loge,log10f

三角函数

\sin a, \cos b, \tan c, \cot d, \sec e, \csc f

sin⁡a,cos⁡b,tan⁡c,cot⁡d,sec⁡e,csc⁡f{\displaystyle \sin a,\cos b,\tan c,\cot d,\sec e,\csc f}sina,cosb,tanc,cotd,sece,cscf

\arcsin a, \arccos b, \arctan c

arcsin⁡a,arccos⁡b,arctan⁡c{\displaystyle \arcsin a,\arccos b,\arctan c}arcsina,arccosb,arctanc

\arccot d, \arcsec e, \arccsc f

arccot⁡d,arcsec⁡e,arccsc⁡f{\displaystyle \operatorname {arccot} d,\operatorname {arcsec} e,\operatorname {arccsc} f}arccotd,arcsece,arccscf

\sinh a, \cosh b, \tanh c, \coth d

sinh⁡a,cosh⁡b,tanh⁡c,coth⁡d{\displaystyle \sinh a,\cosh b,\tanh c,\coth d}sinha,coshb,tanhc,cothd

\operatorname{sh}k, \operatorname{ch}l, \operatorname{th}m, \operatorname{coth}n

sh⁡k,ch⁡l,th⁡m,coth⁡n{\displaystyle \operatorname {sh} k,\operatorname {ch} l,\operatorname {th} m,\operatorname {coth} n}shk,chl,thm,cothn

\operatorname{argsh}o, \operatorname{argch}p, \operatorname{argth}q

argsh⁡o,argch⁡p,argth⁡q{\displaystyle \operatorname {argsh} o,\operatorname {argch} p,\operatorname {argth} q}argsho,argchp,argthq

符号函数，绝对值

\sgn r, \left\vert s \right\vert

sgn⁡r,∣s∣{\displaystyle \operatorname {sgn} r,\left\vert s\right\vert }sgnr,∣s∣

最大值，最小值

\min(x,y), \max(x,y)

min⁡(x,y),max⁡(x,y){\displaystyle \min(x,y),\max(x,y)}min(x,y),max(x,y)

界限，极限#

\min x, \max y, \inf s, \sup t

min⁡x,max⁡y,inf⁡s,sup⁡t{\displaystyle \min x,\max y,\inf s,\sup t}minx,maxy,infs,supt

\lim u, \liminf v, \limsup w

lim⁡u,lim inf⁡v,lim sup⁡w{\displaystyle \lim u,\liminf v,\limsup w}limu,liminfv,limsupw

\lim_{x \to \infty} \frac{1}{n(n+1)}

lim⁡x→∞1n(n+1){\displaystyle \lim_{x \to \infty} \frac{1}{n(n+1)} }x→∞limn(n+1)1

\dim p, \deg q, \det m, \ker\phi

dim⁡p,deg⁡q,det⁡m,ker⁡ϕ{\displaystyle \dim p,\deg q,\det m,\ker \phi}dimp,degq,detm,kerϕ

投射#

\Pr j, \hom l, \lVert z \rVert, \arg z

Pr⁡j,hom⁡l,∥z∥,arg⁡z{\displaystyle \Pr j,\hom l,\lVert z\rVert ,\arg z}Prj,homl,∥z∥,argz

微分及导数#

dt, \mathrm{d}t, \partial t, \nabla\psi

dt,dt,∂t,∇ψ{\displaystyle dt,\mathrm {d} t,\partial t,\nabla \psi }dt,dt,∂t,∇ψ

dy/dx, \mathrm{d}y/\mathrm{d}x, \frac{dy}{dx}, \frac{\mathrm{d}y}{\mathrm{d}x}, \frac{\partial^2}{\partial x_1\partial x_2}y

dy/dx,dy/dx,dydx,dydx,∂2∂x1∂x2y{\displaystyle dy/dx,\mathrm {d} y/\mathrm {d} x,{\frac {dy}{dx} },{\frac {\mathrm {d} y}{\mathrm {d} x} },{\frac {\partial ^{2} }{\partial x_{1}\partial x_{2} }}y}dy/dx,dy/dx,dxdy,dxdy,∂x1∂x2∂2y

\prime, \backprime, f^\prime, f', f'', f^{(3)}, \dot y, \ddot y

′,‵,f′,f′,f′′,f(3) ⁣,y˙,y¨{\displaystyle \prime ,\backprime ,f^{\prime},f',f'',f^{(3)}\!,{\dot {y} },{\ddot {y} }}′,‵,f′,f′,f′′,f(3),y˙,y¨

类字母符号及常数#

\infty, \aleph, \complement, \backepsilon, \eth, \Finv, \hbar

∞,ℵ,∁,∍,ð,Ⅎ,ℏ{\displaystyle \infty ,\aleph ,\complement ,\backepsilon ,\eth ,\Finv ,\hbar}∞,ℵ,∁,∍,ð,Ⅎ,ℏ

\Im, \imath, \jmath, \Bbbk, \ell, \mho, \wp, \Re, \circledS

ℑ,ı,ȷ,k,ℓ,℧,℘,ℜ,Ⓢ{\displaystyle \Im ,\imath ,\jmath ,\Bbbk ,\ell ,\mho ,\wp ,\Re ,\circledS }ℑ,,,k,ℓ,℧,℘,ℜ,Ⓢ

模运算#

s_k \equiv 0 \pmod{m}

sk≡0(modm){\displaystyle s_{k}\equiv 0{\pmod {m} }}sk≡0(modm)

a \bmod b

a mod b{\displaystyle a \bmod b}amodb

\gcd(m, n), \operatorname{lcm}(m, n)

gcd⁡(m,n),lcm⁡(m,n){\displaystyle \gcd(m,n),\operatorname {lcm} (m,n)}gcd(m,n),lcm(m,n)

\mid, \nmid, \shortmid, \nshortmid

∣,∤,∣,∤{\displaystyle \mid ,\nmid ,\shortmid ,\nshortmid}∣,∤,∣,

根号#

\surd, \sqrt{2}, \sqrt[n]{}, \sqrt[3]{\frac{x^3+y^3}{2} }

√,2,n,x3+y323{\displaystyle \surd ,{\sqrt {2} },{\sqrt[{n}]{} },{\sqrt[{3}]{\frac {x^{3}+y^{3} }{2} }} }√,2,n,32x3+y3

运算符#

+, -, \pm, \mp, \dotplus

+,−,±,∓,∔{\displaystyle +,-,\pm ,\mp ,\dotplus}+,−,±,∓,∔

\times, \div, \divideontimes, /, \backslash

×,÷,⋇,/,\{\displaystyle \times ,\div ,\divideontimes ,/,\backslash}×,÷,⋇,/,\

\cdot, * \ast, \star, \circ, \bullet

⋅,∗∗,⋆,∘,∙{\displaystyle \cdot ,*\ast ,\star ,\circ ,\bullet}⋅,∗∗,⋆,∘,∙

\boxplus, \boxminus, \boxtimes, \boxdot

⊞,⊟,⊠,⊡{\displaystyle \boxplus ,\boxminus ,\boxtimes ,\boxdot}⊞,⊟,⊠,⊡

\oplus, \ominus, \otimes, \oslash, \odot

⊕,⊖,⊗,⊘,⊙{\displaystyle \oplus ,\ominus ,\otimes ,\oslash ,\odot}⊕,⊖,⊗,⊘,⊙

\circleddash, \circledcirc, \circledast

⊝,⊚,⊛{\displaystyle \circleddash ,\circledcirc ,\circledast}⊝,⊚,⊛

\bigoplus, \bigotimes, \bigodot

⨁,⨂,⨀{\displaystyle \bigoplus ,\bigotimes ,\bigodot}⨁,⨂,⨀

集合#

\{ \}, \O \empty \emptyset, \varnothing

{},∅∅∅,∅{\displaystyle \{\},\emptyset \emptyset \emptyset ,\varnothing }{},∅∅∅,∅

\in, \notin \not\in, \ni, \not\ni

∈,∉∉,∋,∌{\displaystyle \in ,\notin \not \in ,\ni ,\not \ni}∈,∈/∈,∋,∋

\cap, \Cap, \sqcap, \bigcap

∩,⋒,⊓,⋂{\displaystyle \cap ,\Cap ,\sqcap ,\bigcap}∩,⋒,⊓,⋂

\cup, \Cup, \sqcup, \bigcup, \bigsqcup, \uplus, \biguplus

∪,⋓,⊔,⋃,⨆,⊎,⨄{\displaystyle \cup ,\Cup ,\sqcup ,\bigcup ,\bigsqcup ,\uplus ,\biguplus}∪,⋓,⊔,⋃,⨆,⊎,⨄

\setminus, \smallsetminus, \times

∖,∖,×{\displaystyle \setminus ,\smallsetminus ,\times}∖,∖,×

\subset, \Subset, \sqsubset

⊂,⋐,⊏{\displaystyle \subset ,\Subset ,\sqsubset}⊂,⋐,⊏

\supset, \Supset, \sqsupset

⊃,⋑,⊐{\displaystyle \supset ,\Supset ,\sqsupset}⊃,⋑,⊐

\subseteq, \nsubseteq, \subsetneq, \varsubsetneq, \sqsubseteq

⊆,⊈,⊊,⊊,⊑{\displaystyle \subseteq ,\nsubseteq ,\subsetneq ,\varsubsetneq ,\sqsubseteq}⊆,⊈,⊊,,⊑

\supseteq, \nsupseteq, \supsetneq, \varsupsetneq, \sqsupseteq

⊇,⊉,⊋,⊋,⊒{\displaystyle \supseteq ,\nsupseteq ,\supsetneq ,\varsupsetneq ,\sqsupseteq}⊇,⊉,⊋,,⊒

\subseteqq, \nsubseteqq, \subsetneqq, \varsubsetneqq

⫅,⊈,⫋,⫋{\displaystyle \subseteqq ,\nsubseteqq ,\subsetneqq ,\varsubsetneqq}⫅,,⫋,

\supseteqq, \nsupseteqq, \supsetneqq, \varsupsetneqq

⫆,⊉,⫌,⫌{\displaystyle \supseteqq ,\nsupseteqq ,\supsetneqq ,\varsupsetneqq}⫆,,⫌,

关系符号#

=, \ne, \neq, \equiv, \not\equiv

=,≠,≠,≡,≢{\displaystyle =,\neq ,\neq ,\equiv ,\not \equiv}=,=,=,≡,≡

\doteq, \doteqdot, \overset{\underset{\mathrm{def} }{} }{=}, :=

≐,≑,=def,:={\displaystyle \doteq ,\doteqdot ,{\overset {\underset {\mathrm {def} }{} }{=} },:=}≐,≑,=def,:=

\sim, \nsim, \backsim, \thicksim, \simeq, \backsimeq, \eqsim, \cong, \ncong

∼,≁,∽,∼,≃,⋍,≂,≅,≆{\displaystyle \sim ,\nsim ,\backsim ,\thicksim ,\simeq ,\backsimeq ,\eqsim ,\cong ,\ncong}∼,≁,∽,∼,≃,⋍,≂,≅,≆

\approx, \thickapprox, \approxeq, \asymp, \propto, \varpropto

≈,≈,≊,≍,∝,∝{\displaystyle \approx ,\thickapprox ,\approxeq ,\asymp ,\propto ,\varpropto}≈,≈,≊,≍,∝,∝

<, \nless, \ll, \not\ll, \lll, \not\lll, \lessdot

<,≮,≪,≪̸,⋘,⋘̸,⋖{\displaystyle <,\nless ,\ll ,\not \ll ,\lll ,\not \lll ,\lessdot}<,≮,≪,≪,⋘,⋘,⋖

>, \ngtr, \gg, \not\gg, \ggg, \not\ggg, \gtrdot

>,≯,≫,≫̸,⋙,⋙̸,⋗{\displaystyle>,\ngtr ,\gg ,\not \gg ,\ggg ,\not \ggg ,\gtrdot }>,≯,≫,≫,⋙,⋙,⋗

\le, \leq, \lneq, \leqq, \nleq, \nleqq, \lneqq, \lvertneqq

≤,≤,⪇,≦,≰,≰,≨,≨{\displaystyle \leq ,\leq ,\lneq ,\leqq ,\nleq ,\nleqq ,\lneqq ,\lvertneqq}≤,≤,⪇,≦,≰,,≨,

\ge, \geq, \gneq, \geqq, \ngeq, \ngeqq, \gneqq, \gvertneqq

≥,≥,⪈,≧,≱,≱,≩,≩{\displaystyle \geq ,\geq ,\gneq ,\geqq ,\ngeq ,\ngeqq ,\gneqq ,\gvertneqq}≥,≥,⪈,≧,≱,,≩,

\lessgtr, \lesseqgtr, \lesseqqgtr, \gtrless, \gtreqless, \gtreqqless

≶,⋚,⪋,≷,⋛,⪌{\displaystyle \lessgtr ,\lesseqgtr ,\lesseqqgtr ,\gtrless ,\gtreqless ,\gtreqqless}≶,⋚,⪋,≷,⋛,⪌

\leqslant, \nleqslant, \eqslantless

⩽,≰,⪕{\displaystyle \leqslant ,\nleqslant ,\eqslantless}⩽,,⪕

\geqslant, \ngeqslant, \eqslantgtr

⩾,≱,⪖{\displaystyle \geqslant ,\ngeqslant ,\eqslantgtr}⩾,,⪖

\lesssim, \lnsim, \lessapprox, \lnapprox

≲,⋦,⪅,⪉{\displaystyle \lesssim ,\lnsim ,\lessapprox ,\lnapprox}≲,⋦,⪅,⪉

\gtrsim, \gnsim, \gtrapprox, \gnapprox

≳,⋧,⪆,⪊{\displaystyle \gtrsim ,\gnsim ,\gtrapprox ,\gnapprox}≳,⋧,⪆,⪊

\prec, \nprec, \preceq, \npreceq, \precneqq

≺,⊀,⪯,⋠,⪵{\displaystyle \prec ,\nprec ,\preceq ,\npreceq ,\precneqq}≺,⊀,⪯,⋠,⪵

\succ, \nsucc, \succeq, \nsucceq, \succneqq

≻,⊁,⪰,⋡,⪶{\displaystyle \succ ,\nsucc ,\succeq ,\nsucceq ,\succneqq}≻,⊁,⪰,⋡,⪶

\preccurlyeq, \curlyeqprec

≼,⋞{\displaystyle \preccurlyeq ,\curlyeqprec}≼,⋞

\succcurlyeq, \curlyeqsucc

≽,⋟{\displaystyle \succcurlyeq ,\curlyeqsucc}≽,⋟

\precsim, \precnsim, \precapprox, \precnapprox

≾,⋨,⪷,⪹{\displaystyle \precsim ,\precnsim ,\precapprox ,\precnapprox}≾,⋨,⪷,⪹

\succsim, \succnsim, \succapprox, \succnapprox

≿,⋩,⪸,⪺{\displaystyle \succsim ,\succnsim ,\succapprox ,\succnapprox}≿,⋩,⪸,⪺

几何符号#

\parallel, \nparallel, \shortparallel, \nshortparallel

∥,∦,∥,∦{\displaystyle \parallel ,\nparallel ,\shortparallel ,\nshortparallel}∥,∦,∥,

\perp, \angle, \sphericalangle, \measuredangle, 45^\circ

⊥,∠,∢,∡,45∘{\displaystyle \perp ,\angle ,\sphericalangle ,\measuredangle ,45^{\circ} }⊥,∠,∢,∡,45∘

\Box, \blacksquare, \diamond, \Diamond \lozenge, \blacklozenge, \bigstar

□,■,⋄,◊◊,⧫,★{\displaystyle \Box ,\blacksquare ,\diamond ,\Diamond \lozenge ,\blacklozenge ,\bigstar}□,■,⋄,◊◊,⧫,★

\bigcirc, \triangle, \bigtriangleup, \bigtriangledown

◯,△,△,▽{\displaystyle \bigcirc ,\triangle ,\bigtriangleup ,\bigtriangledown}◯,△,△,▽

\vartriangle, \triangledown

△,▽{\displaystyle \vartriangle ,\triangledown}△,▽

\blacktriangle, \blacktriangledown, \blacktriangleleft, \blacktriangleright

▲,▼,◀,▶{\displaystyle \blacktriangle ,\blacktriangledown ,\blacktriangleleft ,\blacktriangleright}▲,▼,◀,▶

逻辑符号#

\forall, \exists, \nexists

∀,∃,∄{\displaystyle \forall ,\exists ,\nexists}∀,∃,∄

\therefore, \because, \And

∴,∵,&{\displaystyle \therefore ,\because ,\And}∴,∵,&

\or \lor \vee, \curlyvee, \bigvee

∨,∨,∨,⋎,⋁{\displaystyle \lor ,\lor ,\vee ,\curlyvee ,\bigvee}∨,∨,∨,⋎,⋁

\and \land \wedge, \curlywedge, \bigwedge

∧,∧,∧,⋏,⋀{\displaystyle \land ,\land ,\wedge ,\curlywedge ,\bigwedge}∧,∧,∧,⋏,⋀

\bar{q}, \bar{abc}, \overline{q}, \overline{abc},

\lnot \neg, \not\operatorname{R}, \bot, \top

qˉ,abcˉ,q‾,abc‾,{\displaystyle {\bar {q} },{\bar {abc} },{\overline {q} },{\overline {abc} },}qˉ,abcˉ,q,abc,

¬¬,̸R⁡,⊥,⊤{\displaystyle \lnot \neg ,\not \operatorname {R} ,\bot ,\top }¬¬,R,⊥,⊤

\vdash \dashv, \vDash, \Vdash, \models

⊢,⊣,⊨,⊩,⊨{\displaystyle \vdash ,\dashv ,\vDash ,\Vdash ,\models}⊢,⊣,⊨,⊩,⊨

\Vvdash \nvdash \nVdash \nvDash \nVDash

⊪,⊬,⊮,⊭,⊯{\displaystyle \Vvdash ,\nvdash ,\nVdash ,\nvDash ,\nVDash}⊪,⊬,⊮,⊭,⊯

\ulcorner \urcorner \llcorner \lrcorner

⌜⌝⌞⌟{\displaystyle \ulcorner \urcorner \llcorner \lrcorner}┌┐└┘

箭头#

\Rrightarrow, \Lleftarrow

⇛,⇚{\displaystyle \Rrightarrow ,\Lleftarrow}⇛,⇚

\Rightarrow, \nRightarrow, \Longrightarrow \implies

⇒,⇏,⟹, ⟹ {\displaystyle \Rightarrow ,\nRightarrow ,\Longrightarrow ,\implies}⇒,⇏,⟹,⟹

\Leftarrow, \nLeftarrow, \Longleftarrow, \impliedby

⇐,⇍,⟸, ⟸ {\displaystyle \Leftarrow ,\nLeftarrow ,\Longleftarrow, \impliedby}⇐,⇍,⟸,⟸

\Leftrightarrow, \nLeftrightarrow, \Longleftrightarrow \iff

⇔,⇎,⟺ ⟺ {\displaystyle \Leftrightarrow ,\nLeftrightarrow ,\Longleftrightarrow \iff}⇔,⇎,⟺⟺

\Uparrow, \Downarrow, \Updownarrow

⇑,⇓,⇕{\displaystyle \Uparrow ,\Downarrow ,\Updownarrow}⇑,⇓,⇕

\rightarrow \to, \nrightarrow, \longrightarrow

→→,↛,⟶{\displaystyle \rightarrow \to ,\nrightarrow ,\longrightarrow}→→,↛,⟶

\leftarrow \gets, \nleftarrow, \longleftarrow

←←,↚,⟵{\displaystyle \leftarrow \gets ,\nleftarrow ,\longleftarrow}←←,↚,⟵

\leftrightarrow, \nleftrightarrow, \longleftrightarrow

↔,↮,⟷{\displaystyle \leftrightarrow ,\nleftrightarrow ,\longleftrightarrow}↔,↮,⟷

\uparrow, \downarrow, \updownarrow

↑,↓,↕{\displaystyle \uparrow ,\downarrow ,\updownarrow}↑,↓,↕

\nearrow, \swarrow, \nwarrow, \searrow

↗,↙,↖,↘{\displaystyle \nearrow ,\swarrow ,\nwarrow ,\searrow}↗,↙,↖,↘

\mapsto, \longmapsto

↦,⟼{\displaystyle \mapsto ,\longmapsto}↦,⟼

\rightharpoonup \rightharpoondown \leftharpoonup \leftharpoondown \upharpoonleft \upharpoonright \downharpoonleft \downharpoonright \rightleftharpoons \leftrightharpoons

⇀,⇁,↼,↽,↿,↾,⇃,⇂,⇌,⇋{\displaystyle \rightharpoonup ,\rightharpoondown ,\leftharpoonup ,\leftharpoondown ,\upharpoonleft ,\upharpoonright ,\downharpoonleft ,\downharpoonright ,\rightleftharpoons ,\leftrightharpoons}⇀,⇁,↼,↽,↿,↾,⇃,⇂,⇌,⇋

\curvearrowleft \circlearrowleft \Lsh \upuparrows \rightrightarrows \rightleftarrows \rightarrowtail \looparrowright

↶,↺,↰,⇈,⇉,⇄,↣,↬{\displaystyle \curvearrowleft ,\circlearrowleft ,\Lsh ,\upuparrows ,\rightrightarrows ,\rightleftarrows ,\rightarrowtail ,\looparrowright}↶,↺,↰,⇈,⇉,⇄,↣,↬

\curvearrowright \circlearrowright \Rsh \downdownarrows \leftleftarrows \leftrightarrows \leftarrowtail \looparrowleft

↷,↻,↱,⇊,⇇,⇆,↢,↫{\displaystyle \curvearrowright ,\circlearrowright ,\Rsh ,\downdownarrows ,\leftleftarrows ,\leftrightarrows ,\leftarrowtail ,\looparrowleft}↷,↻,↱,⇊,⇇,⇆,↢,↫

\hookrightarrow \hookleftarrow \multimap \leftrightsquigarrow \rightsquigarrow \twoheadrightarrow \twoheadleftarrow

↪,↩,⊸,↭,⇝,↠,↞{\displaystyle \hookrightarrow ,\hookleftarrow ,\multimap ,\leftrightsquigarrow ,\rightsquigarrow ,\twoheadrightarrow ,\twoheadleftarrow}↪,↩,⊸,↭,⇝,↠,↞

特殊符号#

省略号：数学公式中常见的省略号有两种，\ldots 表示与文本底线对齐的省略号，\cdots 表示与文本中线对齐的省略号。

\amalg \% \dagger \ddagger \ldots \cdots

⨿%†‡…⋯{\displaystyle \amalg \%\dagger \ddagger \ldots \cdots}⨿%†‡…⋯

\smile \frown \wr \triangleleft \triangleright

⌣⌢≀◃▹{\displaystyle \smile \frown \wr \triangleleft \triangleright}⌣⌢≀◃▹

\diamondsuit, \heartsuit, \clubsuit, \spadesuit, \Game, \flat, \natural, \sharp

♢,♡,♣,♠,⅁,♭,♮,♯{\displaystyle \diamondsuit ,\heartsuit ,\clubsuit ,\spadesuit ,\Game ,\flat ,\natural ,\sharp}♢,♡,♣,♠,⅁,♭,♮,♯

未分类#

\diagup \diagdown \centerdot \ltimes \rtimes \leftthreetimes \rightthreetimes

╱,╲,⋅,⋉,⋊,⋋,⋌{\displaystyle \diagup ,\diagdown ,\centerdot ,\ltimes ,\rtimes ,\leftthreetimes ,\rightthreetimes}╱,╲,⋅,⋉,⋊,⋋,⋌

\eqcirc \circeq \triangleq \bumpeq \Bumpeq \doteqdot \risingdotseq \fallingdotseq

≖,≗,≜,≏,≎,≑,≓,≒{\displaystyle \eqcirc ,\circeq ,\triangleq ,\bumpeq ,\Bumpeq ,\doteqdot ,\risingdotseq ,\fallingdotseq}≖,≗,≜,≏,≎,≑,≓,≒

\intercal \barwedge \veebar \doublebarwedge \between \pitchfork

⊺,⊼,⊻,⩞,≬,⋔{\displaystyle \intercal ,\barwedge ,\veebar ,\doublebarwedge ,\between ,\pitchfork}⊺,⊼,⊻,⩞,≬,⋔

\vartriangleleft \ntriangleleft \vartriangleright \ntriangleright

⊲,⋪,⊳,⋫{\displaystyle \vartriangleleft ,\ntriangleleft ,\vartriangleright ,\ntriangleright}⊲,⋪,⊳,⋫

\trianglelefteq \ntrianglelefteq \trianglerighteq \ntrianglerighteq

⊴,⋬,⊵,⋭{\displaystyle \trianglelefteq ,\ntrianglelefteq ,\trianglerighteq ,\ntrianglerighteq}⊴,⋬,⊵,⋭

较复杂的表达式#

矩阵、条件表达式、方程组#

语法：

\begin{类型}
公式内容
\end{类型}

类型可以是：矩阵 matrix pmatrix bmatrix Bmatrix vmatrix Vmatrix、条件表达式 cases、多行对齐方程式 aligned、数组 array。

在公式内容中：在每一行中插入 & 来指定需要对齐的内容，在每行结尾处使用 \\ 换行。

无框矩阵#

在开头使用 begin{matrix}，在结尾使用 end{matrix}，在中间插入矩阵元素，每个元素之间插入 & ，并在每行结尾处使用 \\ 。

\begin{matrix}
x & y \\
z & v
\end{matrix}

xyzv{\displaystyle {\begin{matrix}x&y\\z&v\end{matrix} }}xzyv

有框矩阵#

在开头将 matrix 替换为 pmatrix 或 bmatrix 或 Bmatrix 或 vmatrix 或 Vmatrix 。

\begin{vmatrix}
x & y \\
z & v
\end{vmatrix}

∣xyzv∣{\displaystyle {\begin{vmatrix}x&y\\z&v\end{vmatrix} }}xzyv

\begin{Vmatrix}
x & y \\
z & v
\end{Vmatrix}

∥xyzv∥{\displaystyle {\begin{Vmatrix}x&y\\z&v\end{Vmatrix} }}xzyv

使用 \cdots ⋯\cdots⋯ , \ddots ⋱\ddots⋱ , \vdots ⋮\vdots⋮ 来输入省略符号。

\begin{bmatrix}
0      & \cdots & 0      \\
\vdots & \ddots & \vdots \\
0      & \cdots & 0
\end{bmatrix}

[0⋯0⋮⋱⋮0⋯0]{\displaystyle {\begin{bmatrix}0&\cdots &0\\\vdots &\ddots &\vdots \\0&\cdots &0\end{bmatrix} }}0⋮0⋯⋱⋯0⋮0

\begin{Bmatrix}
x & y \\
z & v
\end{Bmatrix}

{xyzv}{\displaystyle {\begin{Bmatrix}x&y\\z&v\end{Bmatrix} }}{xzyv}

\begin{pmatrix}
x & y \\
z & v
\end{pmatrix}

(xyzv){\displaystyle {\begin{pmatrix}x&y\\z&v\end{pmatrix} }}(xzyv)

条件表达式#

f(n) =
\begin{cases}
n/2,  & \text{if }n\text{ is even} \\
3n+1, & \text{if }n\text{ is odd}
\end{cases}

f(n)={n/2,if n is even3n+1,if n is odd{\displaystyle f(n)={\begin{cases}n/2,&{\text{if } }n{\text{ is even} }\\3n+1,&{\text{if } }n{\text{ is odd} }\end{cases} }}f(n)={n/2,3n+1,if n is evenif n is odd

多行等式、同余式#

人们经常想要一列整齐且居中的方程式序列。使用 \begin{aligned}…\end{aligned}。

\begin{aligned}
f(x) & = (m+n)^2 \\
     & = m^2+2mn+n^2 \\
\end{aligned}

f(x)=(m+n)2=m2+2mn+n2{\displaystyle {\begin{aligned}f(x)&=(m+n)^{2}\\&=m^{2}+2mn+n^{2}\\\end{aligned} }}f(x)=(m+n)2=m2+2mn+n2

\begin{aligned}
3^{6n+3}+4^{6n+3}
& \equiv (3^3)^{2n+1}+(4^3)^{2n+1}\\
& \equiv 27^{2n+1}+64^{2n+1}\\
& \equiv 27^{2n+1}+(-27)^{2n+1}\\
& \equiv 27^{2n+1}-27^{2n+1}\\
& \equiv 0 \pmod{91}\\
\end{aligned}

36n+3+46n+3≡(33)2n+1+(43)2n+1≡272n+1+642n+1≡272n+1+(−27)2n+1≡272n+1−272n+1≡0(mod91){\displaystyle {\begin{aligned}3^{6n+3}+4^{6n+3}&\equiv (3^{3})^{2n+1}+(4^{3})^{2n+1}\\&\equiv 27^{2n+1}+64^{2n+1}\\&\equiv 27^{2n+1}+(-27)^{2n+1}\\&\equiv 27^{2n+1}-27^{2n+1}\\&\equiv 0{\pmod {91} }\\\end{aligned} }}36n+3+46n+3≡(33)2n+1+(43)2n+1≡272n+1+642n+1≡272n+1+(−27)2n+1≡272n+1−272n+1≡0(mod91)

\begin{alignedat}{3}
f(x) & = (m-n)^2 \\
f(x) & = (-m+n)^2 \\
     & = m^2-2mn+n^2 \\
\end{alignedat}

{\displaystyle {\begin{alignedat}{3}f(x)&=(m-n)^{2}\\f(x)&=(-m+n)^{2}\\&=\bm^{2}-2mn+n^{2}\\\end{alignedat} }}

方程组#

\begin{cases}
3x + 5y +  z \\
7x - 2y + 4z \\
-6x + 3y + 2z
\end{cases}

{3x+5y+z7x−2y+4z−6x+3y+2z{\displaystyle {\begin{cases}3x+5y+z\\7x-2y+4z\\-6x+3y+2z\end{cases} }}⎩⎨⎧3x+5y+z7x−2y+4z−6x+3y+2z

或

\left\{\begin{aligned}
3x + 5y +  z \\
7x - 2y + 4z \\
-6x + 3y + 2z
\end{aligned}\right.

{3x+5y+z7x−2y+4z−6x+3y+2z\left\{\begin{aligned} 3x + 5y + z \\ 7x - 2y + 4z \\ -6x + 3y + 2z \end{aligned}\right.⎩⎨⎧3x+5y+z7x−2y+4z−6x+3y+2z

数组与表格#

通常，一个格式化后的表格比单纯的文字或排版后的文字更具有可读性。数组和表格均以 \begin{array} 开头，并在其后定义列数及每一列的文本对齐属性，c l r 分别代表居中、左对齐及右对齐。若需要插入垂直分割线，在定义式中插入 | ，若要插入水平分割线，在下一行输入前插入 \hline 。与矩阵相似，每行元素间均须要插入 & ，每行元素以 \\ 结尾，最后以 \end{array} 结束数组。

例子：

\begin{array}{c|lcr}
n & \text{左对齐} & \text{居中对齐} & \text{右对齐} \\
\hline
1 & 0.24 & 1 & 125 \\
2 & -1 & 189 & -8 \\
3 & -20 & 2000 & 1+10i
\end{array}

显示：

n左对齐居中对齐右对齐10.2411252−1189−83−2020001+10i\begin{array}{c|lcr} n & \text{左对齐} & \text{居中对齐} & \text{右对齐} \\ \hline 1 & 0.24 & 1 & 125 \\ 2 & -1 & 189 & -8 \\ 3 & -20 & 2000 & 1+10i \end{array}n123左对齐0.24−1−20居中对齐11892000右对齐125−81+10i

例子：

\begin{array}{lcl}
z        & = & a \\
f(x,y,z) & = & x + y + z
\end{array}

显示：

z=af(x,y,z)=x+y+z{\displaystyle {\begin{array}{lcl}z&=&a\\f(x,y,z)&=&x+y+z\end{array} }}zf(x,y,z)==ax+y+z

例子：

\begin{array}{lcr}
z        & = & a \\
f(x,y,z) & = & x + y + z
\end{array}

显示：

z=af(x,y,z)=x+y+z{\displaystyle {\begin{array}{lcr}z&=&a\\f(x,y,z)&=&x+y+z\end{array} }}zf(x,y,z)==ax+y+z

例子：

\begin{array}{ccc}
a & b & S \\
\hline
0&0&1\\
0&1&1\\
1&0&1\\
1&1&0\\
\end{array}

显示：

abS001011101110{\displaystyle {\begin{array}{ccc}a&b&S\\\hline 0&0&1\\0&1&1\\1&0&1\\1&1&0\\\end{array} }}a0011b0101S1110

嵌套数组或表格#

多个数组/表格可 互相嵌套 并组成一组数组/一组表格。使用嵌套前必须声明 $$ 符号。

例子：

% outer vertical array of arrays 外层垂直表格
\begin{array}{c}
    % inner horizontal array of arrays 内层水平表格
    \begin{array}{cc}
        % inner array of minimum values 内层"最小值"数组
        \begin{array}{c|cccc}
        \text{min} & 0 & 1 & 2 & 3\\
        \hline
        0 & 0 & 0 & 0 & 0\\
        1 & 0 & 1 & 1 & 1\\
        2 & 0 & 1 & 2 & 2\\
        3 & 0 & 1 & 2 & 3
        \end{array}
    &
        % inner array of maximum values 内层"最大值"数组
        \begin{array}{c|cccc}
        \text{max}&0&1&2&3\\
        \hline
        0 & 0 & 1 & 2 & 3\\
        1 & 1 & 1 & 2 & 3\\
        2 & 2 & 2 & 2 & 3\\
        3 & 3 & 3 & 3 & 3
        \end{array}
    \end{array}
    % 内层第一行表格组结束
    \\
    % inner array of delta values 内层第二行 Delta 值数组
        \begin{array}{c|cccc}
        \Delta&0&1&2&3\\
        \hline
        0 & 0 & 1 & 2 & 3\\
        1 & 1 & 0 & 1 & 2\\
        2 & 2 & 1 & 0 & 1\\
        3 & 3 & 2 & 1 & 0
        \end{array}
        % 内层第二行表格组结束
\end{array}

显示：

min012300000101112012230123max012300123111232222333333Δ012300123110122210133210% outer vertical array of arrays 外层垂直表格 \begin{array}{c} % inner horizontal array of arrays 内层水平表格 \begin{array}{cc} % inner array of minimum values 内层"最小值"数组 \begin{array}{c|cccc} \text{min} & 0 & 1 & 2 & 3\\ \hline 0 & 0 & 0 & 0 & 0\\ 1 & 0 & 1 & 1 & 1\\ 2 & 0 & 1 & 2 & 2\\ 3 & 0 & 1 & 2 & 3 \end{array} & % inner array of maximum values 内层"最大值"数组 \begin{array}{c|cccc} \text{max}&0&1&2&3\\ \hline 0 & 0 & 1 & 2 & 3\\ 1 & 1 & 1 & 2 & 3\\ 2 & 2 & 2 & 2 & 3\\ 3 & 3 & 3 & 3 & 3 \end{array} \end{array} % 内层第一行表格组结束 \\ % inner array of delta values 内层第二行 Delta 值数组 \begin{array}{c|cccc} \Delta&0&1&2&3\\ \hline 0 & 0 & 1 & 2 & 3\\ 1 & 1 & 0 & 1 & 2\\ 2 & 2 & 1 & 0 & 1\\ 3 & 3 & 2 & 1 & 0 \end{array} % 内层第二行表格组结束 \end{array}min012300000101112012230123max012300123111232222333333Δ012300123110122210133210

用数组实现带分割符号的矩阵#

例子：

$$
\left[
    \begin{array}{cc|c}
      1&2&3\\
      4&5&6
    \end{array}
\right]
$$

显示：

[123456]\left[ \begin{array}{cc|c} 1&2&3\\ 4&5&6 \end{array} \right][142536]

其中 cc|c 代表在一个三列矩阵中的第二和第三列之间插入分割线。

字体#

希腊字母#

输入 \小写希腊字母英文全称 和 \首字母大写希腊字母英文全称 来分别输入小写和大写希腊字母。

\Alpha \Beta \Gamma \Delta \Epsilon \Zeta \Eta \Theta

ABΓΔEZHΘ{\displaystyle \mathrm {A} \mathrm {B} \Gamma \Delta \mathrm {E} \mathrm {Z} \mathrm {H} \Theta }ABΓΔEZHΘ

\Iota \Kappa \Lambda \Mu \Nu \Xi \Omicron \Pi

IKΛMNOΞΠ{\displaystyle \mathrm {I} \mathrm {K} \Lambda \mathrm {M} \mathrm {N} \mathrm {O} \Xi \Pi }IKΛMNOΞΠ

\Rho \Sigma \Tau \Upsilon \Phi \Chi \Psi \Omega

PΣTΥΦXΨΩ{\displaystyle \mathrm {P} \Sigma \mathrm {T} \Upsilon \Phi \mathrm {X} \Psi \Omega }PΣTΥΦXΨΩ

\alpha \beta \gamma \delta \epsilon \zeta \eta \theta

αβγδϵζηθ{\displaystyle \alpha \beta \gamma \delta \epsilon \zeta \eta \theta}αβγδϵζηθ

\iota \kappa \lambda \mu \nu \omicron \xi \pi

ικλμνoξπ{\displaystyle \iota \kappa \lambda \mu \nu \mathrm {o} \xi \pi }ικλμνoξπ

\rho \sigma \tau \upsilon \phi \chi \psi \omega

ρστυϕχψω{\displaystyle \rho \sigma \tau \upsilon \phi \chi \psi \omega}ρστυϕχψω

部分字母有变量专用形式，以 \var- 开头。

\varepsilon \digamma \varkappa \varpi

εϝϰϖ{\displaystyle \varepsilon \digamma \varkappa \varpi}εϝϰϖ

\varrho \varsigma \vartheta \varphi

ϱςϑφ{\displaystyle \varrho \varsigma \vartheta \varphi}ϱςϑφ

希伯来符号#

\aleph \beth \gimel \daleth

ℵℶℷℸ{\displaystyle \aleph \beth \gimel \daleth}ℵℶℷℸ

部分字体的简称#

若要对公式的某一部分字符进行字体转换，可以用 {\字体 {需转换的部分字符} } 命令，其中 \字体 部分可以参照下表选择合适的字体。一般情况下，公式默认为意大利体 italicitalicitalic 。

输入	说明	显示	输入	说明	显示
`\rm`	罗马体	Sample\rm{Sample}Sample	`\cal`	花体	SAMPLE\cal{SAMPLE}SAMPLE
`\it`	意大利体	Sample\it{Sample}Sample	`\Bbb`	黑板粗体	SAMPLE\Bbb{SAMPLE}SAMPLE
`\bf`	粗体	Sample\bf{Sample}Sample	`\mit`	数学斜体	\mitSAMPLE\mit{SAMPLE}\mitSAMPLE
`\sf`	等线体	Sample\sf{Sample}Sample	`\scr`	手写体	\scrSAMPLE\scr{SAMPLE}\scrSAMPLE
`\tt`	打字机体	Sample\tt{Sample}Sample	`\frak`	旧德式字体	Sample\frak{Sample}Sample

所有字体#

黑板报粗体#

\mathbb{ABCDEFGHI}

ABCDEFGHI{\displaystyle \mathbb {ABCDEFGHI} }ABCDEFGHI

\mathbb{JKLMNOPQR}

JKLMNOPQR{\displaystyle \mathbb {JKLMNOPQR} }JKLMNOPQR

\mathbb{STUVWXYZ}

STUVWXYZ{\displaystyle \mathbb {STUVWXYZ} }STUVWXYZ

粗体#

\mathbf{ABCDEFGHI}

ABCDEFGHI{\displaystyle \mathbf {ABCDEFGHI} }ABCDEFGHI

\mathbf{JKLMNOPQR}

JKLMNOPQR{\displaystyle \mathbf {JKLMNOPQR} }JKLMNOPQR

\mathbf{STUVWXYZ}

STUVWXYZ{\displaystyle \mathbf {STUVWXYZ} }STUVWXYZ

\mathbf{abcdefghijklm}

abcdefghijklm{\displaystyle \mathbf {abcdefghijklm} }abcdefghijklm

\mathbf{nopqrstuvwxyz}

nopqrstuvwxyz{\displaystyle \mathbf {nopqrstuvwxyz} }nopqrstuvwxyz

\mathbf{0123456789}

0123456789{\displaystyle \mathbf {0123456789} }0123456789

粗体希腊字母#

\boldsymbol{\Alpha\Beta\Gamma\Delta\Epsilon\Zeta\Eta\Theta}

ABΓΔEZHΘ{\displaystyle {\boldsymbol {\mathrm {A} \mathrm {B} \Gamma \Delta \mathrm {E} \mathrm {Z} \mathrm {H} \Theta } }}ABΓΔEZHΘ

\boldsymbol{\Iota\Kappa\Lambda\Mu\Nu\Xi\Pi\Rho}

IKΛMNΞΠP{\displaystyle {\boldsymbol {\mathrm {I} \mathrm {K} \Lambda \mathrm {M} \mathrm {N} \Xi \Pi \mathrm {P} } }}IKΛMNΞΠP

\boldsymbol{\Sigma\Tau\Upsilon\Phi\Chi\Psi\Omega}

ΣTΥΦXΨΩ{\displaystyle {\boldsymbol {\Sigma \mathrm {T} \Upsilon \Phi \mathrm {X} \Psi \Omega } }}ΣTΥΦXΨΩ

\boldsymbol{\alpha\beta\gamma\delta\epsilon\zeta\eta\theta}

αβγδϵζηθ{\displaystyle {\boldsymbol {\alpha \beta \gamma \delta \epsilon \zeta \eta \theta} }}αβγδϵζηθ

\boldsymbol{\iota\kappa\lambda\mu\nu\xi\pi\rho}

ικλμνξπρ{\displaystyle {\boldsymbol {\iota \kappa \lambda \mu \nu \xi \pi \rho} }}ικλμνξπρ

\boldsymbol{\sigma\tau\upsilon\phi\chi\psi\omega}

στυϕχψω{\displaystyle {\boldsymbol {\sigma \tau \upsilon \phi \chi \psi \omega} }}στυϕχψω

\boldsymbol{\varepsilon\digamma\varkappa\varpi}

εϝϰϖ{\displaystyle {\boldsymbol {\varepsilon \digamma \varkappa \varpi} }}εϝϰϖ

\boldsymbol{\varrho\varsigma\vartheta\varphi}

ϱςϑφ{\displaystyle {\boldsymbol {\varrho \varsigma \vartheta \varphi} }}ϱςϑφ

斜体（拉丁字母默认）#

\mathit{0123456789}

0123456789{\displaystyle {\mathit {0123456789} }}0123456789

斜体希腊字母（小写字母默认）#

\mathit{\Alpha\Beta\Gamma\Delta\Epsilon\Zeta\Eta\Theta}

ABΓΔEZHΘ{\displaystyle {\mathit {\mathrm {A} \mathrm {B} \Gamma \Delta \mathrm {E} \mathrm {Z} \mathrm {H} \Theta } }}ABΓΔEZHΘ

\mathit{\Iota\Kappa\Lambda\Mu\Nu\Xi\Pi\Rho}

IKΛMNΞΠP{\displaystyle {\mathit {\mathrm {I} \mathrm {K} \Lambda \mathrm {M} \mathrm {N} \Xi \Pi \mathrm {P} } }}IKΛMNΞΠP

\mathit{\Sigma\Tau\Upsilon\Phi\Chi\Psi\Omega}

ΣTΥΦXΨΩ{\displaystyle {\mathit {\Sigma \mathrm {T} \Upsilon \Phi \mathrm {X} \Psi \Omega } }}ΣTΥΦXΨΩ

罗马体#

\mathrm{ABCDEFGHI}

ABCDEFGHI{\displaystyle \mathrm {ABCDEFGHI} }ABCDEFGHI

\mathrm{JKLMNOPQR}

JKLMNOPQR{\displaystyle \mathrm {JKLMNOPQR} }JKLMNOPQR

\mathrm{STUVWXYZ}

STUVWXYZ{\displaystyle \mathrm {STUVWXYZ} }STUVWXYZ

\mathrm{abcdefghijklm}

abcdefghijklm{\displaystyle \mathrm {abcdefghijklm} }abcdefghijklm

\mathrm{nopqrstuvwxyz}

nopqrstuvwxyz{\displaystyle \mathrm {nopqrstuvwxyz} }nopqrstuvwxyz

\mathrm{0123456789}

0123456789{\displaystyle \mathrm {0123456789} }0123456789

无衬线体#

\mathsf{ABCDEFGHI}

ABCDEFGHI{\displaystyle {\mathsf {ABCDEFGHI} }}ABCDEFGHI

\mathsf{JKLMNOPQR}

JKLMNOPQR{\displaystyle {\mathsf {JKLMNOPQR} }}JKLMNOPQR

\mathsf{STUVWXYZ}

STUVWXYZ{\displaystyle {\mathsf {STUVWXYZ} }}STUVWXYZ

\mathsf{abcdefghijklm}

abcdefghijklm{\displaystyle {\mathsf {abcdefghijklm} }}abcdefghijklm

\mathsf{nopqrstuvwxyz}

nopqrstuvwxyz{\displaystyle {\mathsf {nopqrstuvwxyz} }}nopqrstuvwxyz

\mathsf{0123456789}

0123456789{\displaystyle {\mathsf {0123456789} }}0123456789

无衬线体希腊字母（仅大写）#

\mathsf{\Alpha \Beta \Gamma \Delta \Epsilon \Zeta \Eta \Theta}

ABΓΔEZHΘ{\displaystyle {\mathsf {\mathrm {A} \mathrm {B} \Gamma \Delta \mathrm {E} \mathrm {Z} \mathrm {H} \Theta } }}ABΓΔEZHΘ

\mathsf{\Iota \Kappa \Lambda \Mu \Nu \Xi \Pi \Rho}

IKΛMNΞΠP{\displaystyle {\mathsf {\mathrm {I} \mathrm {K} \Lambda \mathrm {M} \mathrm {N} \Xi \Pi \mathrm {P} } }}IKΛMNΞΠP

\mathsf{\Sigma \Tau \Upsilon \Phi \Chi \Psi \Omega}

ΣTΥΦXΨΩ{\displaystyle {\mathsf {\Sigma \mathrm {T} \Upsilon \Phi \mathrm {X} \Psi \Omega } }}ΣTΥΦXΨΩ

手写体 / 花体#

\mathcal{ABCDEFGHI}

ABCDEFGHI{\displaystyle {\mathcal {ABCDEFGHI} }}ABCDEFGHI

\mathcal{JKLMNOPQR}

JKLMNOPQR{\displaystyle {\mathcal {JKLMNOPQR} }}JKLMNOPQR

\mathcal{STUVWXYZ}

STUVWXYZ{\displaystyle {\mathcal {STUVWXYZ} }}STUVWXYZ

Fraktur 体#

\mathfrak{ABCDEFGHI}

ABCDEFGHI{\displaystyle {\mathfrak {ABCDEFGHI} }}ABCDEFGHI

\mathfrak{JKLMNOPQR}

JKLMNOPQR{\displaystyle {\mathfrak {JKLMNOPQR} }}JKLMNOPQR

\mathfrak{STUVWXYZ}

STUVWXYZ{\displaystyle {\mathfrak {STUVWXYZ} }}STUVWXYZ

\mathfrak{abcdefghijklm}

abcdefghijklm{\displaystyle {\mathfrak {abcdefghijklm} }}abcdefghijklm

\mathfrak{nopqrstuvwxyz}

nopqrstuvwxyz{\displaystyle {\mathfrak {nopqrstuvwxyz} }}nopqrstuvwxyz

\mathfrak{0123456789}

0123456789{\displaystyle {\mathfrak {0123456789} }}0123456789

小型手写体#

{\scriptstyle\text{abcdefghijklm} }

abcdefghijklm{\displaystyle {\scriptstyle {\text{abcdefghijklm} }} }abcdefghijklm

混合字体#

特征 | 语法 | 渲染效果

斜体字符（忽略空格）

x y z

xyz{\displaystyle xyz}xyz

非斜体字符

\text{x y z}

x y z{\displaystyle {\text{x y z} }}x y z

混合斜体（差）

\text{if} n \text{is even}

ifnis even{\displaystyle {\text{if} }n{\text{is even} }}ifnis even

混合斜体（好）

\text{if }n\text{ is even}

if n is even{\displaystyle {\text{if } }n{\text{ is even} }}if n is even

混合斜体（替代品：~ 或者 \ 强制空格）

\text{if}~n\ \text{is even}

if n is even{\displaystyle {\text{if} }~n\ {\text{is even} }}if n is even

注释文本#

使用 \text {文字} 来添加注释文本（注释文本不会被识别为公式，不用斜体显示）。\text {文字}中仍可以使用 $公式$ 插入其它公式。

例子：

f(n)= \begin{cases}
n/2, & \text {if $n$ is even} \\
3n+1, &\text{if $n$ is odd}
\end{cases}

显示：

f(n)={n/2,if n is even3n+1,if n is oddf(n)= \begin{cases} n/2, & \text {if}\ n\ \text{is even} \\ 3n+1, & \text {if}\ n\ \text{is odd} \end{cases}f(n)={n/2,3n+1,if n is evenif n is odd

Sublime Text

Fri, 08 Dec 2023 00:00:00 GMT

快捷键#

选择类#

Ctrl+D 选中光标所占的文本，继续操作则会选中下一个相同的文本。
Alt+F3 选中文本按下快捷键，即可一次性选择全部的相同文本进行同时编辑。举个栗子：快速选中并更改所有相同的变量名、函数名等。
Ctrl+L 选中整行，继续操作则继续选择下一行，效果和 Shift+↓ 效果一样。
Ctrl+Shift+L 先选中多行，再按下快捷键，会在每行行尾插入光标，即可同时编辑这些行。
Ctrl+Shift+M 选择括号内的内容（继续选择父括号）。举个栗子：快速选中删除函数中的代码，重写函数体代码或重写括号内里的内容。
Ctrl+M 光标移动至括号内结束或开始的位置。
Ctrl+Enter 在下一行插入新行。举个栗子：即使光标不在行尾，也能快速向下插入一行。
Ctrl+Shift+Enter 在上一行插入新行。举个栗子：即使光标不在行首，也能快速向上插入一行。
Ctrl+Shift+[ 选中代码，按下快捷键，折叠代码。
Ctrl+Shift+] 选中代码，按下快捷键，展开代码。
Ctrl+K+0 展开所有折叠代码。
Ctrl+← 向左单位性地移动光标，快速移动光标。
Ctrl+→ 向右单位性地移动光标，快速移动光标。
shift+↑ 向上选中多行。
shift+↓ 向下选中多行。
Shift+← 向左选中文本。
Shift+→ 向右选中文本。
Ctrl+Shift+← 向左单位性地选中文本。
Ctrl+Shift+→ 向右单位性地选中文本。
Ctrl+Shift+↑ 将光标所在行和上一行代码互换（将光标所在行插入到上一行之前）。
Ctrl+Shift+↓ 将光标所在行和下一行代码互换（将光标所在行插入到下一行之后）。
Ctrl+Alt+↑ 向上添加多行光标，可同时编辑多行。
Ctrl+Alt+↓ 向下添加多行光标，可同时编辑多行。

编辑类#

Ctrl+J 合并选中的多行代码为一行。举个栗子：将多行格式的CSS属性合并为一行。
Ctrl+Shift+D 复制光标所在整行，插入到下一行。
Tab 向右缩进。
Shift+Tab 向左缩进。
Ctrl+K+K 从光标处开始删除代码至行尾。
Ctrl+Shift+K 删除整行。
Ctrl+/ 注释单行。
Ctrl+Shift+/ 注释多行。
Ctrl+K+U 转换大写。
Ctrl+K+L 转换小写。
Ctrl+Z 撤销。
Ctrl+Y 恢复撤销。
Ctrl+U 软撤销，感觉和 Gtrl+Z 一样。
Ctrl+F2 设置书签
Ctrl+T 左右字母互换。
F6 单词检测拼写

搜索类#

Ctrl+F 打开底部搜索框，查找关键字。
Ctrl+shift+F 在文件夹内查找，与普通编辑器不同的地方是sublime允许添加多个文件夹进行查找，略高端，未研究。
Ctrl+P 打开搜索框。举个栗子：1、输入当前项目中的文件名，快速搜索文件，2、输入@和关键字，查找文件中函数名，3、输入：和数字，跳转到文件中该行代码，4、输入#和关键字，查找变量名。
Ctrl+G 打开搜索框，自动带：，输入数字跳转到该行代码。举个栗子：在页面代码比较长的文件中快速定位。
Ctrl+R 打开搜索框，自动带@，输入关键字，查找文件中的函数名。举个栗子：在函数较多的页面快速查找某个函数。
Ctrl+：打开搜索框，自动带#，输入关键字，查找文件中的变量名、属性名等。
Ctrl+Shift+P 打开命令框。场景栗子：打开命名框，输入关键字，调用sublime text或插件的功能，例如使用package安装插件。
Esc 退出光标多行选择，退出搜索框，命令框等。

显示类#

Ctrl+Tab 按文件浏览过的顺序，切换当前窗口的标签页。
Ctrl+PageDown 向左切换当前窗口的标签页。
Ctrl+PageUp 向右切换当前窗口的标签页。
Alt+Shift+1 窗口分屏，恢复默认1屏（非小键盘的数字）
Alt+Shift+2 左右分屏-2列
Alt+Shift+3 左右分屏-3列
Alt+Shift+4 左右分屏-4列
Alt+Shift+5 等分4屏
Alt+Shift+8 垂直分屏-2屏
Alt+Shift+9 垂直分屏-3屏
Ctrl+K+B 开启/关闭侧边栏。
F11 全屏模式
Shift+F11 免打扰模式

对拍#

来源：流苏Lss

首先，如果对d.cpp这个文件进行对拍，需要创建d__Good.cpp和d__Generator.cpp两个文件，前者是正确代码，而后者是数据生成的代码，注意两个文件中都带有两个下划线。

然后，在需要对拍的文件中按下ctrl+shift+p找到FastOlympicCoding:Make Stress，然后回车即可

数据生成

#include<bits/stdc++.h>
#define int long long
using i64 = long long;

std::mt19937 rnd(std::chrono::steady_clock().now().time_since_epoch().count());

int rng(int l, int r) { // [l, r]
    return rnd() % (r - l + 1) + l;
}

void array(int n) { // Generates an array with n elements
    int m = 1E9;
    std::vector<int> a(n);
    for (int i = 0; i < n; i++) {
        a[i] = rng(0, m);
        std::cout << a[i] << " \n"[i == n - 1];
    }
}

void cand(int m, int n) { // Generate m cands from 1 to n
    for (int i = 0; i < m; i++) {
        int l = rng(1, n);
        int r = rng(1, n);

        if (l > r) {
            std::swap(l, r);
        }

        std::cout << l << " " << r << "\n";
    }
}

void tree(int n) { // Generate a tree with n vertices
    int m = 1E9;
    for (int i = 1; i < n; i++) {
        int p = rng(0, i - 1);
        int v = rng(1, m);
        std::cout << p + 1 << " " << i + 1 << " " << v << "\n";
    }
}

void graph(int n, int m) {
// Generate an undirected graph with n vertices and m edges. There are no double edges or self-rings in the graph, and must be connected.
    std::vector<std::pair<int, int>> e;
    std::map<std::pair<int, int>, bool> f;

    std::cout << n << " " << m << "\n";

    for (int i = 1; i < n; i++) {
        int p = rng(0, i - 1);
        e.push_back(std::make_pair(p, i));
        f[std::make_pair(p, i)] = f[std::make_pair(i, p)] = true;
    }

    // debug(f);
    for (int i = n; i <= m; i++) {
        int x, y;
        do {
            x = rng(0, n - 1);
            y = rng(0, n - 1);
        } while (x == y || f.count(std::make_pair(x, y)));

        e.push_back(std::make_pair(x, y));
        f[std::make_pair(x, y)] = f[std::make_pair(y, x)] = true;
    }

    std::shuffle(e.begin(), e.end(), rnd);

    for (auto [x, y] : e) {
        std::cout << x + 1 << " " << y + 1 << "\n";
    }
}

signed main() {
    int t = 5;
    std::cout << t << "\n";

    while (t--) {
        graph(3, 3);
    }

    return 0;
}