17、分离逻辑下的破坏性红黑树实现与验证

分离逻辑下的破坏性红黑树实现与验证

1. 分离逻辑库基础

在软件开发中，分离逻辑（Separation Logic，SL）是一种强大的工具，用于推理程序对堆内存的操作。有一个基于 KIV 的分离逻辑库，它与 Isabelle 和 Coq 的库类似。

1.1 堆谓词与基本定义

SL 公式通过堆谓词 hP : heap('a) → bool 进行编码，堆谓词描述了堆 h 的结构。以下是一些基本定义：
- 空堆 ：最简单的堆是空堆 emp ，定义为 emp(h) ↔ h = ∅ 。
- 单元素堆 ： r → obj 描述了一个只包含一个引用 r 指向对象 obj 的单元素堆，它是一个高阶函数，类型为 (ref('a) × 'a) → heap('a) → bool ，定义为 (r → obj)(h) ↔ h = (∅++ r)[r := obj] ∧ r ≠ null 。
- 分离合取 ：更复杂的堆可以使用分离合取 hP0 * hP1 来描述，它断言堆由两个不相交的部分组成，分别满足 hP0 和 hP1 。其类型为 (heap('a) → bool) × (heap('a) → bool) → (heap('a) → bool) ，定义为 (hP0 * hP1)(h) ↔ ∃h0, h1. h0 ⊥ h1 ∧ h = h0 ∪ h1 ∧ hP0(h0) ∧ hP1(h1) 。

1.2 常见指针数据结构抽象

除了基本定义，KIV 库还包含了对常用指针数据结构（如单/双向链表、二叉树）的各种抽象。这些抽象有助于证明指针结构上算法的功能正确性（包括内存安全性）。下面以红黑树的实现为例进行说明。

2. 模块化软件系统

在开发复杂软件系统时，采用分层组件和契约式数据精化的概念。

2.1 组件定义

组件是一个抽象数据类型 (ST, Init, (Opj)j∈J) ，包括：
- 状态集合 ST 。
- 初始状态集合 Init ⊆ ST 。
- 操作集合 Opj ⊆ Inj × ST × ST × Outj ，操作 Opj 接收输入 Ini ，输出 Outj ，并修改组件的状态。

操作使用 ASMs 的操作方法进行契约式指定，对于操作 Opj ，给出前置条件 prej 和程序 αj ，形式为 opj#(inj ; st; outj) pre prej {αj } 。同时，也可以通过 init#(ininit; st; outinit) {αinit} 来定义初始状态。

2.2 规格与实现组件

组件分为规格组件和实现组件：
- 规格组件 ：用于建模子系统的功能需求，通常利用代数函数和非确定性来保持简单。
- 实现组件 ：通常是确定性的，使用能通过代码生成器生成可执行 Scala 或 C 代码的构造。

实现组件的功能正确性通过对应规格组件的数据精化来证明，用 C ≤ A 表示 C 是 A 的精化，其中 C = (ST C, InitC, (OpC j )j∈J) ， A = (ST A, InitA, (OpA j )j∈J) ，且 C 和 A 具有相同的操作集合 J 。

2.3 精化证明

精化证明使用前向模拟 R ⊆ ST A × ST C 和交换图进行，对于所有 j ∈ J 有正确性证明义务：

R(stA, stC) ∧ preA j (stA)
→ ⟨|opC j #(inj ; stC; outj)|⟩⟨opA j #(inj ; stA; out′ j)⟩(R(stA, stC) ∧ outj = out′ j)

此外，对于每个组件可以给出状态不变式 inv(st) ，它必须由所有操作 (Opj)j∈J 保持。还可以为操作给出单独的后置条件 postj(st) ，扩展其不变式契约。

2.4 子组件与模块化

为了便于开发大型系统，引入子组件的模块化概念。一个组件（通常是实现组件）可以使用一个或多个组件（通常是规格组件）作为子组件，客户端组件只能通过调用子组件的接口操作来访问其子组件的状态。使用子组件可以构建精化层次结构，将复杂的精化任务分解为多个更易管理的任务。

以下是数据精化与子组件关系的 mermaid 流程图：

graph LR
    classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px;
    A0(Specification A0):::process --> C0(Implementation C0):::process
    A1(Specification A1):::process --> C1(Implementation C1):::process
    A2(Specification A2):::process --> C2(Implementation C2):::process
    C0 -->|Uses| A1
    C1 -->|Uses| A2

3. 破坏性红黑树的实现

红黑树是一种高效的有序集（或多重集）数据结构。为了抽象红黑树的复杂实现细节，使用简单的规格组件 RBSET 。

3.1 RBSET 组件

RBSET 的状态是一个全序元素集合，由类型为 set(tord) 的状态变量 rbs 确定。初始时， rbs 为空集 ∅ ，可以通过 insert# 和 remove# 操作插入或删除元素。此外，还有检查集合是否为空、元素是否在集合中以及选择最小元素的接口过程。

3.2 红黑树的精化层次

红黑树的实现分为两个精化步骤，以降低使用分离逻辑对堆进行推理的复杂度：
1. 第一步： RBTREE(RBTBASIC) ≤ RBSET ：证明红黑树可以实现集合抽象，并保持所有红黑树属性。这里使用代数数据类型 rbtree 而不是堆数据结构。
2. 第二步： RBTHEAP ≤ RBTBASIC ：证明堆实现符合代数数据类型。

3.3 RBTBASIC 组件

RBTBASIC 的状态由代数红黑树 rbt 和两个路径 curPath 和 auxPath 组成，路径使用枚举类型 lrdesc := LEFT | RIGHT 的列表表示。 RBTBASIC 提供了对 rbtree 进行基本操作的接口，如在树的指定位置插入元素、对特定子树进行左右旋转等。

3.4 RBTHEAP 组件

RBTHEAP 的状态包含一个堆 rbh 和指向树根的指针 rootRef ，以及与 curPath 和 auxPath 对应的指针 curRef 和 auxRef 。堆存储 rbnode 类型的节点，节点包含元素、颜色以及指向左右子树和父节点的指针。

以下是红黑树精化层次的表格：
| 精化步骤 | 描述 |
| — | — |
| RBTREE(RBTBASIC) ≤ RBSET | 使用代数数据类型 rbtree 实现集合抽象并保持红黑树属性 |
| RBTHEAP ≤ RBTBASIC | 堆实现符合代数数据类型 |

3.5 红黑树操作示例：删除元素

以 RBTREE 组件中的 remove# 操作为例，其操作流程如下：
1. 重置路径指向根节点。
2. 调用 search#(elem) 进行二分查找，更新 curPath 指向要删除的元素（如果找到）。
3. 如果到达 SENTINEL ，停止搜索并终止删除操作。
4. 如果找到元素，根据节点的左右子节点情况进行替换操作。
5. 调用 removeFixup# 修复红黑树属性。

以下是 RBTREE 中 remove# 操作的部分代码示例：

// 重置路径指向根节点
curPath := [];
auxPath := [];
// 二分查找元素
search#(elem);
if (reached SENTINEL) {
    exists := false;
    return;
}
if (node has SENTINEL as left or right child) {
    // 简单替换操作
    ...
} else {
    auxPath := curPath;
    rbtbasic right#;
    leftMost#;
    // 移动元素
    ...
    // 替换子树
    rbt[curPath] := rbt[curPath].right;
}
// 修复红黑树属性
removeFixup#;

RBTHEAP 的操作与 RBTBASIC 类似，但基于指针结构。例如，访问 curRef 指向的节点只需解引用指针 rbh[curRef ] ，而不是遍历整个路径。

红黑树删除元素操作的 mermaid 流程图如下：

graph TD
    classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px;
    A(Reset paths):::process --> B(Search for element):::process
    B -->|Reached SENTINEL| C(Abort removal):::process
    B -->|Element found| D(Check children):::process
    D -->|SENTINEL child| E(Simple substitution):::process
    D -->|No SENTINEL child| F(Update paths):::process
    F --> G(Move element):::process
    G --> H(Replace subtree):::process
    E --> I(Fix up tree):::process
    H --> I
    I --> J(End):::process

4. 破坏性红黑树的验证

4.1 功能属性规格化

对于红黑树的验证，需要将功能属性规格化为 RBTREE 的不变式。在接口调用之间， rbt 必须是有效的红黑树（用 isRbtree(rbt) 表示），并且是有效的搜索树，即其元素必须有序（用 isOrdered(rbt) 表示）。

一个非空红黑树具有三个主要属性：
- 树的根节点为黑色。
- 红色节点的两个子节点必须为黑色。
- 从任何节点到叶子节点的每条路径必须包含相同数量的黑色节点。

isRbtree(rbt) 的定义如下：

isRbtree(rbt) ↔
{
    rbt = SENTINEL ∨
    (rbt.color = BLACK ∧ redCorrect(rbt, RED) ∧ sameBlacks(rbt))
}

其中， redCorrect(rbt, parCol) （ parCol 是父节点的颜色）指定了前两个属性， sameBlacks(rbt) 指定了最后一个属性。这两个谓词都是递归定义的，例如，对于红色节点的 redCorrect 公理为：

redCorrect(Node(e, RED, left, right), parCol) ↔
parCol = BLACK ∧ redCorrect(left, RED) ∧ redCorrect(right, RED)

在删除节点时，需要定义额外的谓词（用 D 表示），以允许在特定路径上违反这些属性，例如：

redCorrectD(Node(e, col, left, right), parCol, []) ↔
redCorrect(left, col) ∧ redCorrect(right, col)

4.2 RBTREE(RBTBASIC) ≤ RBSET 的精化证明

RBTREE(RBTBASIC) ≤ RBSET 的精化通过以下前向模拟证明，其中 elems 计算树中存储的元素集合：

abstraction relation
rbs = elems(rbt)

这个简单的抽象允许将 RBSET 的集合修改编码到 RBTREE 的契约中。例如， remove# 操作的契约规定从树中删除元素 elem （ elems(rbt) = elems(rbt‵) -- elem ，其中 rbt‵ 是操作执行前 rbt 的值）。其他修改辅助过程的契约确保它们不会改变树中存储的元素集合。

需要注意的是，精化证明不需要 isRbtree(rbt) 不变式，但需要 isOrdered(rbt) ，因为否则树搜索将不正确。

4.3 RBTHEAP ≤ RBTBASIC 的精化证明

证明 RBTHEAP ≤ RBTBASIC 使用分离逻辑和以下不涉及任何红黑树属性的抽象：

abstraction relation
rbh[rootRef, curPath] = curRef
∧ rbh[rootRef, auxPath] = auxRef
∧ abs(rootRef, null, rbt)(rbh)

前两个公式断言引用 curRef 和 auxRef 分别对应于路径 curPath 和 auxPath 。堆谓词 abs : (ref(rbnode) × ref(rbnode) × rbtree(tord)) → heap(rbnode) → bool 将从 rootRef 开始的指针树抽象为代数树 rbt 。 abs 的递归定义如下：

abs(rootRef, pRef, SENTINEL)(rbh) ↔ rootRef = null ∧ rbh = ∅
abs(rootRef, pRef, Node(elem, col, l, r))(rbh) ↔
∃lRef, rRef. (
    (rootRef → Node(elem, col, pRef, lRef, rRef))
    * abs(lRef, rootRef, l)
    * abs(rRef, rootRef, r)
)(rbh)

对于 SENTINEL ，堆 rbh 必须为空，这确保了没有内存泄漏。对于节点，堆被分离为三个不相交的部分。

证明利用了每个操作最多修改树中一个位置的特点，通过以下两个基本定理进行：
- 拆分定理 ：

p ∈ rbt → (abs(rootRef, pRef, rbt)(rbh) ↔
∃pthRef, pPthRef.
(abspath(rootRef, pRef, rbt, p, pthRef, pPthRef)
* abs(pthRef, pPthRef, rbt[p]))(rbh))

• 连接定理 ：

(abspath(rootRef, pRef, rbt, p, pthRef, pPthRef)
* abs(pthRef, pPthRef, rbt0))(rbh)
→ abs(rootRef, pRef, rbt[p := rbt0])(rbh)

4.4 旋转操作的实现与证明

以右旋转操作为例， RBTBASIC 中的 rotateRight# 操作接收路径 p 作为参数，执行相应位置的右旋转：

rotateRight#(p)
{
    let rbt0 = rotateRightSubtree(rbt[p]);
    rbt[p] := rbt0;
}

RBTHEAP 中的 rotateRight# 操作接收引用 ref 作为输入，通过更新指针来执行旋转：

rotateRight#(ref)
auxiliary
pre ref ∈ rbh ∧ rbh[ref].left ∈ rbh;
{
    let lRef = rbh[ref].left in {
        rbh[ref].left := rbh[lRef].right;
        if rbh[lRef].right ≠ null then rbh[rbh[lRef].right].parent := ref;
        if lRef ≠ null then rbh[lRef].parent := rbh[ref].parent;
        if rbh[ref].parent ≠ null then {
            if ref = rbh[rbh[ref].parent].right
                then rbh[rbh[ref].parent].right := lRef;
            else rbh[rbh[ref].parent].left := lRef;
        } else rootRef := lRef;
        rbh[lRef].right := ref;
        if ref ≠ null then rbh[ref].parent := lRef;
    }
}

以下是 RBTHEAP 右旋转操作的 mermaid 流程图：

graph TD
    classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px;
    A(Check preconditions):::process --> B(Set lRef):::process
    B --> C(Update ref.left):::process
    C --> D(Update right child's parent):::process
    D --> E(Update lRef's parent):::process
    E --> F(Update parent's child pointer):::process
    F -->|Parent is null| G(Update rootRef):::process
    F -->|Parent is not null| H(Continue):::process
    G --> I(Update lRef.right):::process
    H --> I
    I --> J(Update ref's parent):::process
    J --> K(End):::process

4.5 总结

通过分离逻辑和抽象关系，成功证明了红黑树实现的功能正确性和内存安全性。将红黑树的实现分为两个精化步骤，降低了推理复杂度，使得每个步骤的操作更加简单。同时，利用不变式和契约简化了精化证明过程。

以下是红黑树验证相关要点的表格总结：
| 验证部分 | 关键内容 |
| — | — |
| 功能属性规格化 | isRbtree(rbt) 和 isOrdered(rbt) 不变式 |
| RBTREE(RBTBASIC) ≤ RBSET 证明 | 前向模拟 rbs = elems(rbt) |
| RBTHEAP ≤ RBTBASIC 证明 | 分离逻辑和抽象关系 rbh[rootRef, curPath] = curRef 等 |
| 旋转操作证明 | 利用拆分和连接定理 |

综上所述，这种方法为复杂数据结构的实现和验证提供了一种有效的途径，可应用于其他类似的数据结构和算法。