大型网络，电力，芯片算力系统监监与故障定位

阶乘布线监测法 · 通用说明

通用表述 · 不含特定行业与厂商实现 · v1.1（文字精修版）

v1.1 修订：深化"积分/微分算子恒为 1 → 判定无选择 → 全部确定"的原理表述；
明确阶乘是结构生成规则（递归法则）；补 4.1–4.3 算子形式化与 §11 布线图引用。

0. 一句话定义

用阶乘把物理布线与监测结构做成同一棵树：布线严格按阶乘逐级递减（9→8→7→…→1），积分算子（上报）与微分算子（定位）恒为 1；其余一切——编码、判定、定位、查表——全部退化为常数操作。

0.5 原理精义

• 恒为 1 = 无选择：只要每级分支数由层位置唯一决定，积分（上报）与微分（定位）就各自只有一条路径可走。判定层不需要任何"二选一/多选一"的规则——因为选择根本不存在，一切都是确定的。
• 选择只在结构缺口处复活：一旦布线偏离阶乘（分支数不符、跨层旁路、多点共测），某级就不再唯一，判别逻辑必然被重新引入。三种典型错配恰好"长出"三种二次判别，不是巧合，而是恒为 1 被破坏的必然结果。
• 阶乘是结构生成规则：9→8→…→1 不是查表得来的 9 个数字，而是一条生成规则——“每下降一级，扇出减 1”。整棵树由这一条规则递归生成，不需要逐层配置分支数。
• 递归法则整体一致：任意子树与整树遵循同一条规则（自相似）；局部规则即整体规则，整体行为即局部行为的放大。差分算子恒为 1 在每个尺度上同时成立，因此不存在"需要特殊处理"的节点。

0.6 与双链双曲率螺旋方程的对应（作者理论框架）

阶乘树是双链双曲率螺旋方程的离散结构表达（作者理论框架内的对应，非实证结论）：

• 双链 = 同一条测地线的两个方向：积分链（上报，沿链 OR 上升）与微分链（定位，沿链下降取子）是同一条路径的两个方向，互逆——双链不是两条线，是一条测地线的上行与下行；
• 双曲率：
  • 曲率 = 结构增长量：每级扇出 −1，恒定。整树由恒定结构增长率生成；
  • 测地线 = 实际物理增长量：根→叶路径长度 = 层数 = 恒定（9）。每个物理点的"实际量"在测地线上唯一；
• 同步增长：测地线（层数）与结构（根扇出）由同一条规则 分支_k = N − k 同时决定——结构加一级，每点测地线同步 +1；测地线加长，结构按同一规则放大。二者是同一条递归规则的两个投影，必然同步；
• 算子恒为 1 = 耦合点：结构曲率恒定 ⇒ 路径唯一且等长 ⇒ 积分沿路径 OR 结果唯一（无选择）⇒ 微分沿路径取子唯一（选择退化为读取）⇒ 积分与微分在测地线上一致 ⇒ 自主回归定位：报警沿测地线积分到根，定位沿同一测地线微分回叶，全程无判别、全确定。

1. 核心结构

1.1 阶乘树

层级自上而下，每级分支数恰好递减 1：

叶节点总数：

9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 = 9! = 362 880

末级的 1 个分支即"差分单位 1"——它是整个结构的收敛终点。

1.2 积分与微分算子恒为 1

每级分支数由层位置直接决定，不需要查表、不需要配置、不需要逐层改代码：

• 分解唯一：每个物理点对应唯一一条路径码，无重复、无遗漏；
• 终点自识别：末级分支数自然递减到 1，b = 1 本身就是终点标记，无需额外字段或判断；
• 积分与微分互逆：上报（向上 OR 累积）与定位（向下逐级取子）走的是同一条路径、方向相反，不需要两张表。

1.3 递归生成规则

给定叶容量 9!，树的生成规则只有一条：

等价地：分支_k = 10 − k（k = 1..9）。叶总数 = Π 分支_k = 9!。

推论：结构参数只有两个——层数（9）与根扇出（9）；其余全部由规则推出。 想放大容量，只需同规则加层（10 级 → 10!），算法、编码、代码均不变。

1.4 自相似与递归不变性

• 任取一个内部节点，其下子树仍然是"逐级减 1"的阶乘结构（只是起点分支变小）；
• 因此"上报—定位"这对互逆操作在每一层都成立，与规模无关；
• 定位步数 = 层数 = 常数，与叶数量无关——这是递归规则带来的不变性；
• 局部规则即整体规则：一个点的事只经过它到顶的那一条链，兄弟节点与其他子树完全不受影响。

2. 唯一硬约束：布线严格按阶乘

这是全方法唯一不可妥协的部分。

物理布线（电力通道、网络通道、监测通道）与监测结构必须逐点、逐边、逐层一一对应：

满足 → 积分/微分算子恒为 1 → 定位唯一、无判别。任一处错配 → 结构缺口 → 二次判别必然被重新引回来。

2.1 为什么错配必然长出新判别

记第 k 层实际分支数 b_k，规则要求 B_k = 10 − k：

这不是巧合：三种情况都指向同一结论——一旦 b_k ≠ B_k，恒为 1 被破坏，确定性的代价就变成了额外的判别规则。判别的存在不是设计缺陷，而是结构缺口的"指纹"。

2.2 按对象要求，不强套

• 想一网多测：电力、网络、芯片等对象按同一棵阶乘树对齐（同级同分支、同一物理点各占一位）；
• 只监测一类对象：只需该对象的物理布线与测点按阶乘匹配，其余对象不必纳入。

只要纳入监测，就必须与这棵树同构。

3. 编码

编码只有两个字段：

[ 对象字段 b 位 ] ‖ [ 路径码 ]

• 对象字段：一类监测对象占一位；加一类，只加一位；
• 路径码：由各层分支号顺序拼接，采用紧凑二进制——第一级若只有 2 个点则占 1 位，其后每层按实际分支数取最短位宽。

路径码就是微分的积分轨迹：它把"从根到叶"的每一步选择记录下来；因为每级分支数由层位置决定，这些"选择"实际上是规则的读取结果，编码时无判别、解码时无歧义。

编码的职责只有一个：定位。它不携带故障类型、严重程度、处置信息。

4. 监测层只做两件事

• 上报：父位 = 子位 OR（子树内有异常即置 1，全正常才 0）；
• 定位：从顶层沿异常位逐级下降，命中即停（多故障时返回最小路径码者，全量枚举由逐点下降/DFS 收集）；
• 各管各层：一个点的事只经过它到顶的那一条链，兄弟节点与其他子树完全不受影响；
• 不含故障类型、主因、处置——这些全部属于业务层。

4.1 积分算子（上报）的形式化

对叶的异常做"沿路径 OR 累积"：

父位 = ∨ 子位

算子作用于路径，恒为 1——因为路径唯一，OR 的结果唯一。无论叶状态如何变化，向上传递的结果都只有一种写法。

4.2 微分算子（定位）的形式化

对根异常做"沿异常位逐级取子"：

每级选择 = 从 B_k 个候选中取置位者

因上报已保证异常位沿链连续置位，每级恰好 1 个候选置位，选择退化为读取——这正是"恒为 1"在定位侧的体现：不是从多个候选中判断，而是读取唯一确定的那一个。

4.3 互逆性

积分把叶状态合成到根；微分把根状态分解回叶。两条操作在同一棵树上互为反函数，不需要第二张表。

5. 定位与查表

异常位沿链 OR 上升
↓
顶层收到 1
↓
沿异常位逐级下降 → 叶编号
↓
查位置表 LOC[叶编号] → 具体物理位置

位置表是静态只读台账（部署时生成，运行期不变），每条记录定长，索引 O(1)。

它不是算法，是事实记录。 它相当于号码本：编号是地址，位置是姓名，查一下就完事，不需要计算。

6. 容量扩展

单组封顶 10!；超出则叠加"大级"：

容量每加一级 ×3 628 800（乘性），操作数每加一级 +常数（加性）——容量与计算彻底解耦。

说明：演示实现取 9 级（9! = 362,880 叶），即 10! 树的上界演示；方法上限 10 级（10!），加级与叠级都只改规模、不改规则。算法、编码、代码均不变，只增加物理规模。

7. 一网多测

一类监测对象 = 编码里的一位。

• 电力、网络、芯片等对象共用同一棵树、同一套布线；
• 各对象独立置位、独立上报、独立下降定位，互不干扰；
• 加一类监测，只加一位编码——不加线、不改算法；
• 物理上同一点挂多类对象时，各类异常分别占位，可分别定位到同一点；
• 多故障并发时，路径数 = 故障数（线性），不爆炸。

8. 计算量与代码体积

• 算力恒定：定位步数只与层数有关，与规模无关；
• 代码体积恒定：规模只作为数据存在，二进制体积不随规模变化；
• 工艺无关：算力需求绝对量极小，任何工艺等级的芯片都足以承载；
• 增量维护：单点状态变化只写它到顶的一条链（层深次数），不触碰其他节点。

9. 实测验证结论

在可运行实现（Rust 版，逐函数对应 C 版）上验证通过的性质：

• 编译零警告；
• 编解码双射——全部 362,880 个叶节点逐一验证，无重复、无遗漏；
• 单点定位唯一命中（多种规模、多种位置）；
• 并发路径数 = 故障数（线性，不爆炸）；
• 清位无残留（位图可完全复原）；
• 代码体积恒定（规模改变，二进制不变）；
• 性能：10 万次「定位 + 查表 + 格式化」≈ 39 ms（约 390 ns/次）。

10. 边界与注意事项

11. 布线图

11.1 阶乘扇出与三通道对应

图A（阶乘扇出结构）与图B（工程布线图）见 docs/阶乘布线图.png：

• 图A：9 级阶乘扇出，每级分支数递减 1，末级 = 差分单位 1；唯一路径上标"上报↑（积分统计）/ 定位↓（微分回归）"；全树叶数 = 9! = 362,880；
• 图B：电力 / 网络 / 监测三通道逐级同构、测点一一对应；虚线横连线 = 同一物理位置，三类对象在同一棵树的三个编码位上，共线共点、不另布线。

11.2 一致与错配校验

• 三通道同构对齐 ⇒ 差分算子恒为 1（确定，无判别）；
• 测点一一对应 ⇒ 异常沿唯一路径上报（积分）与定位（微分），结果唯一；
• 任一通道错配（分支数不符 / 跨层旁路 / 多点共用测点）⇒ 漏报、误报、歧义，必须引入判别。

12. 一句话收束

*硬的是布线：必须严格按阶乘逐级对应，积分/微分算子才恒为 1，判定中才没有选择，一切才确定。软的都极简：编码加一位、判定用一位、定位走一条路、查表一次索引。阶乘是物理规则，是结构的生成规则，整体逻辑一致的递归法则。
`/ ============================================================

• 阶乘监测系统 · Rust 版端到端整合验证
• 移植自 C 版（docs/legacy/factorial_monitor_c.c），
• 链路逐函数对应：理论(阶乘/差分恒为1)
• -> 结构(9! 树, 分支 9…1)
• -> 编码(对象字段 + 路径码, factoradic)
• -> 上报(沿链 OR 上升)
• -> 下降定位(唯一路径, 命中即停)
• -> 查表(叶编号 -> 物理位置)
• -> 一网多测(供电/数据网络/芯片 共用一树)
• -> 多源定位(各对象独立下降)
• 与 C 版的两处差异（均为加强，见 REVIEW.md）：
• 双射由"抽查 46 个"改为"全量 362,880 个逐一验证"（文档声称即全量）；
• 随机故障集使用确定性 xorshift64（种子 20261030），
• 与 C 的 rand() 序列不同，但验证的性质相同。

• 构建：cargo build –release
• 运行：cargo run –release
• ============================================================ /
  use std::time::Instant;
  const NUM_DEPTH: usize = 10; / 深度 0…9 : 根 -> 叶 /
  const NUM_BRANCH: usize = 9; / 每层分支数 : 9,8,7,6,5,4,3,2,1 /
  const NUM_OBJ: usize = 3; / 供电 / 数据网络 / 芯片 /
  const NUM_LEAVES: u32 = 362_880; / 9! /
  const TOTAL_NODES: usize = 986_410; / 1+9+72+504+…+362880 /
  const BRANCH: [u32; NUM_BRANCH] = [9, 8, 7, 6, 5, 4, 3, 2, 1];
  const FACT: [u32; 10] = [1, 1, 2, 6, 24, 120, 720, 5_040, 40_320, 362_880];
  const OBJ_NETWORK: u8 = 1;
  const OBJ_CHIP: u8 = 2;
  const OBJ_NAME: [&str; NUM_OBJ] = [“供电”, “数据网络”, “芯片”];
  / —————- 结构 + 状态位图 + 位置台账 + 操作计数 —————- /
  struct Monitor {
  nodes: [u32; NUM_DEPTH], / 各层节点数 /
  offset: [u32; NUM_DEPTH + 1], / 各层起始扁平索引 /
  mask: Vec, / bit k = 对象 k 在该节点子树有异常 /
  loc: Vec<[u8; 9]>, / 叶编号 -> 9 级物理位置分量（静态只读台账） /
  ops: u64, / 操作计数 /
  }
  impl Monitor {
  fn new() -> Self {
  let mut nodes = [0u32; NUM_DEPTH];
  let mut offset = [0u32; NUM_DEPTH + 1];
  nodes[0] = 1;
  for d in 1…NUM_DEPTH {
  nodes[d] = nodes[d – 1] * BRANCH[d – 1];
  }
  offset[0] = 0;
  for d in 0…NUM_DEPTH {
  offset[d + 1] = offset[d] + nodes[d];
  }
  let mut m = Monitor {
  nodes,
  offset,
  mask: vec![0u8; TOTAL_NODES],
  loc: vec![[0u8; 9]; NUM_LEAVES as usize],
  ops: 0,
  };
  / 位置台账：部署时生成，运行期只读 /
  for id in 0…NUM_LEAVES {
  m.loc[id as usize] = m.decompose(id);
  }
  m
  }
  / ================= factoradic：叶编号 <-> 路径各位 =================
  • 位权 8!,7!,…,1!；digits[0] 权 8!(0…8) … digits[7] 权 1!(0…1)，digits[8]=0
  • ================================================================= /
    fn decompose(&self, id: u32) -> [u8; 9] {
    let mut digits = [0u8; 9];
    let mut rem = id;
    for i in 0…8 {
    let f = FACT[8 – i];
    digits[i] = (rem / f) as u8;
    rem %= f;
    }
    digits[8] = 0;
    digits
    }
    fn compose(&self, digits: &[u8; 9]) -> u32 {
    let mut id = 0u32;
    for i in 0…8 {
    id += digits[i] as u32 * FACT[8 – i];
    }
    id
    }
    / ================= 位置台账查询 ================= /
    fn format_pos(&self, leaf: u32) -> String {
    let d = &self.loc[leaf as usize];
    format!(
    “园区{}-机房{}-机柜{}-排{}-槽{}-单元{}-板{}-端口{}-点位{}”,
    d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8]
    )
    }
    fn print_code(&self, leaf: u32) -> String {
    let d = self.decompose(leaf);
    let mut s = String::new();
    for x in d {
    s.push_str(&x.to_string());
    }
    s
    }
    / ================= 上报：沿链 OR 上升（根 + 9 级） ================= /
    fn mark_leaf(&mut self, leaf: u32, obj: u8) {
    let digits = self.decompose(leaf);
    let mut node = self.offset[0];
    self.mask[node as usize] |= 1u8 << obj;
    self.ops += 1;
    for d in 0…9 {
    node = self.offset[d + 1] + (node – self.offset[d]) * BRANCH[d] + digits[d] as u32;
    self.mask[node as usize] |= 1u8 << obj;
    self.ops += 1;
    }
    }
    / ================= 清位：沿链自底向上重算 ================= /
    fn clear_leaf(&mut self, leaf: u32, obj: u8) {
    let digits = self.decompose(leaf);
    let mut path = [0u32; 10];
    let mut node = 0u32;
    path[0] = node;
    for d in 0…9 {
    node = self.offset[d + 1] + (node – self.offset[d]) * BRANCH[d] + digits[d] as u32;
    path[d + 1] = node;
    }
    self.mask[path[9] as usize] &= !(1u8 << obj);
    self.ops += 1;
    for d in (0…9).rev() {
    let p = path[d];
    let base = self.offset[d + 1] + (p – self.offset[d]) * BRANCH[d];
    let mut agg = 0u8;
    for k in 0…BRANCH[d] {
    agg |= self.mask[(base + k) as usize];
    self.ops += 1;
    }
    self.mask[p as usize] = agg;
    }
    }
    / ================= 下降定位：唯一下降到叶（命中即停） ================= /
    fn locate_obj(&mut self, obj: u8) -> Option {
    if self.mask[0] & (1u8 << obj) == 0 {
    return None; / 根无异常 -> 无故障 /
    }
    let mut node = 0u32;
    let mut digits = [0u8; 9];
    for d in 0…9 {
    let base = self.offset[d + 1] + (node – self.offset[d]) * BRANCH[d];
    let mut hit = false;
    for k in 0…BRANCH[d] {
    self.ops += 1;
    if self.mask[(base + k) as usize] & (1u8 << obj) != 0 {
    node = base + k;
    digits[d] = k as u8;
    hit = true;
    break;
    }
    }
    if !hit {
    return None;
    }
    }
    Some(self.compose(&digits))
    }
    / ================= 并发：收集某对象的全部异常叶 ================= /
    fn dfs_collect(&self, depth: usize, node: u32, obj: u8, digits: &mut [u8; 9], out: &mut Vec) {
    if self.mask[node as usize] & (1u8 << obj) == 0 {
    return;
    }
    if depth == 9 {
    out.push(self.compose(digits));
    return;
    }
    let base = self.offset[depth + 1] + (node – self.offset[depth]) * BRANCH[depth];
    for k in 0…BRANCH[depth] {
    digits[depth] = k as u8;
    self.dfs_collect(depth + 1, base + k, obj, digits, out);
    }
    }
    fn reset(&mut self) {
    self.mask.fill(0);
    }
    }
    / 确定性伪随机数（种子 20261030，替代 C 的 rand()） /
    struct XorShift64 {
    s: u64,
    }
    impl XorShift64 {
    fn new(seed: u64) -> Self {
    XorShift64 {
    s: if seed == 0 { 0x9E37_79B9_7F4A_7C15 } else { seed },
    }
    }
    fn next(&mut self) -> u64 {
    let mut x = self.s;
    x ^= x << 13;
    x ^= x >> 7;
    x ^= x << 17;
    self.s = x;
    x
    }
    }
    / ================= 主流程 ================= /
    fn main() {
    println!(““);
    println!(” 阶乘监测系统 · 端到端整合验证（Rust 版）“);
    println!(” 结构 9! = 362,880 叶 | 分支 9->8->…->1 | 差分算子恒为 1");
    println!("”);
    let mut m = Monitor::new();
    / ———- 场景 0：结构自检 ———- /
    println!(“\\n【场景 0】结构自检”);
    println!(" {:<6} {:<6} {:<12} {:<14}“, “深度”, “分支”, “该层节点数”, “累计节点数”);
    for d in 0…NUM_DEPTH {
    let b = if d < NUM_BRANCH { BRANCH[d] } else { 0 };
    println!(
    " L{:<5} {:<6} {:<12} {:<14}”,
    d, b, m.nodes[d], m.offset[d + 1]
    );
    }
    println!(
    " 叶 {} + 内部 {} = 总节点 {}",
    m.nodes[9],
    m.offset[NUM_DEPTH] – m.nodes[9],
    m.offset[NUM_DEPTH]
    );
    / 双射全量验证：362,880 个叶逐一 decompose -> compose（文档声称即为全量） /
    let mut bij_ok = true;
    for id in 0…NUM_LEAVES {
    let dg = m.decompose(id);
    if m.compose(&dg) != id {
    bij_ok = false;
    break;
    }
    }
    println!(
    " factoradic 双射全量验证 362,880 个：{}“,
    if bij_ok { “全部一致” } else { “存在不一致” }
    );
    let pathbits: u32 = BRANCH
    .iter()
    .map(|&b| {
    let mut nb = 0u32;
    while (1u32 << nb) < b {
    nb += 1;
    }
    nb
    })
    .sum();
    let mut objbits = 0u32;
    while (1u32 << objbits) < NUM_OBJ as u32 {
    objbits += 1;
    }
    println!(
    " 编码宽度：对象字段 {} 位 + 路径码 {} 位 = {} 位”,
    objbits,
    pathbits,
    objbits + pathbits
    );
    println!(
    " 位图内存：{} 节点 * 1 字节 = {:.1} KB",
    TOTAL_NODES,
    TOTAL_NODES as f64 / 1024.0
    );
    m.reset();
    / ———- 场景 1：单点单对象 ———- /
    println!(“\\n【场景 1】单点单对象故障”);
    {
    let target = 123_456u32;
    m.ops = 0;
    m.mark_leaf(target, OBJ_NETWORK);
    println!(
    " 注入：叶#{}（路径码 {}）对象={}“,
    target,
    m.print_code(target),
    OBJ_NAME[OBJ_NETWORK as usize]
    );
    println!(” 上报：沿链 OR 上升 {} 次位操作", m.ops);
    m.ops = 0;
    let got = m.locate_obj(OBJ_NETWORK);
    match got {
    Some(g) => {
    let pos = m.format_pos(g);
    println!(
    " 定位：{} 叶#{} 下降比较 {} 次",
    if g == target { “唯一命中” } else { “未命中” },
    g,
    m.ops
    );
    println!(" 查表：LOC[{}] -> {}“, g, pos);
    }
    None => println!(” 定位：未命中"),
    }
    }
    / ———- 场景 2：同一物理点 3 类对象 ———- /
    println!(“\\n【场景 2】同一物理点挂 3 类对象（一网多测）”);
    m.reset();
    {
    let pt = 5_000u32;
    m.ops = 0;
    for o in 0…NUM_OBJ as u8 {
    m.mark_leaf(pt, o);
    }
    println!(" 同一物理点 #{} 挂 {} 类对象，合计上报 {} 次", pt, NUM_OBJ, m.ops);
    let mut all_hit = true;
    for o in 0…NUM_OBJ as u8 {
    m.ops = 0;
    if let Some(g) = m.locate_obj(o) {
    let pos = m.format_pos(g);
    if g != pt {
    all_hit = false;
    }
    println!(
    " {:<8} -> 叶#{:<7} {} | {}“,
    OBJ_NAME[o as usize],
    g,
    if g == pt { “一致” } else { “不一致” },
    pos
    );
    } else {
    all_hit = false;
    println!(” {:<8} -> 未命中", OBJ_NAME[o as usize]);
    }
    }
    println!(
    " 结论：{}",
    if all_hit { “三类对象全部唯一定位到同一点” } else { “存在偏差” }
    );
    }
    / ———- 场景 3：多点并发多对象 ———- /
    println!(“\\n【场景 3】多点并发多对象”);
    m.reset();
    {
    const NBAD: usize = 20;
    let mut bad: Vec<(u32, u8)> = Vec::new();
    let mut rng = XorShift64::new(20261030u64);
    while bad.len() < NBAD {
    let lf = (rng.next() % NUM_LEAVES as u64) as u32;
    let ob = (rng.next() % NUM_OBJ as u64) as u8;
    if bad.iter().any(|&(l, o)| l == lf && o == ob) {
    continue;
    }
    bad.push((lf, ob));
    }
    m.ops = 0;
    for &(lf, ob) in &bad {
    m.mark_leaf(lf, ob);
    }
    println!(
    " 注入 {} 个故障（跨 {} 类对象），合计上报 {} 次",
    NBAD, NUM_OBJ, m.ops
    );
    let mut total_found = 0usize;
    for o in 0…NUM_OBJ as u8 {
    let mut out: Vec = Vec::new();
    let mut digits = [0u8; 9];
    m.dfs_collect(0, 0, o, &mut digits, &mut out);
    let ids: Vec = out.iter().map(|x| format!(“#{}”, x)).collect();
    println!(
    " {:<8} 检出 {} 个异常点：{}“,
    OBJ_NAME[o as usize],
    out.len(),
    ids.join(” “)
    );
    total_found += out.len();
    }
    println!(
    " 路径数：{}（期望 {}）{}，未见指数增长”,
    total_found,
    NBAD,
    if total_found == NBAD { “一致” } else { “不一致” }
    );
    }
    / ———- 场景 4：清位与残留检查 ———- /
    println!(“\\n【场景 4】清位与残留检查”);
    {
    m.reset();
    let target = 123_456u32;
    m.ops = 0;
    m.mark_leaf(target, OBJ_CHIP);
    m.mark_leaf(200_000, OBJ_CHIP);
    println!(" 置位 2 点（对象=芯片），上报 {} 次", m.ops);
    m.ops = 0;
    m.clear_leaf(target, OBJ_CHIP);
    let after_c1 = m.ops; / 第一次清位操作数 /
    let msg = match m.locate_obj(OBJ_CHIP) {
    Some(g) => format!(“叶#{} {}”, g, if g == 200_000 { “（正确）” } else { “（错误）” }),
    None => “未命中（错误）”.to_string(),
    };
    let after_loc = m.ops; / 含定位开销 /
    m.clear_leaf(200_000, OBJ_CHIP);
    let locate_ops = after_loc – after_c1;
    let clear_total = m.ops – locate_ops; / 两次清位合计（与 C 版口径一致） /
    println!(" 清掉叶#{} 后，剩余定位 = {}“, target, msg);
    let left = m.mask.iter().filter(|&&v| v != 0).count();
    println!(
    " 全部清除后残留非零节点 = {} {}（清位共 {} 次）”,
    left,
    if left == 0 { “无残留” } else { “有残留” },
    clear_total
    );
    }
    / ———- 场景 5：性能 ———- */
    println!(“\\n【场景 5】性能：10 万次 定位 + 查表 + 格式化”);
    m.reset();
    {
    m.ops = 0;
    m.mark_leaf(123_456, OBJ_CHIP);
    let t0 = Instant::now();
    let mut acc: u64 = 0;
    for _ in 0…100_000 {
    if let Some(g) = m.locate_obj(OBJ_CHIP) {
    let pos = m.format_pos(g);
    acc += pos.as_bytes()[0] as u64;
    }
    }
    let ms = t0.elapsed().as_secs_f64() * 1e3;
    println!(
    " 10 万次总耗时 {:.3} ms，平均 {:.1} ns/次（校验和 {}）“,
    ms,
    ms * 10.0,
    acc
    );
    }
    println!(”\\n============================================================“);
    println!(” 链路贯通：结构 -> 编码 -> 上报 -> 下降定位 -> 查表 -> 多对象多源");
    println!(“============================================================”);
    }
    `