exp+fix: 轮次31——确定界连续认证抓到段内碰撞，但单段P50 22.9ms进不了20ms；自适应cap收益经交错复测撤回

- Kin.cert_lever 用三角不等式给全姿态位移界（替代 JS 随机采样×1.05），界量级 5.93–48.86 mm/整步
- Kin.certify_segments 批量前沿二分+每根查询预算：48 固定段中预算32判安全37/碰撞1/未知拒10，
  第180题1.08–1.10s漏检段以5次查询判碰撞；未知只拒不放
- 修 seg_seg_dist 第二条退化成点不投影（模型内退化胶囊686受影响）；但7586个加密点的组最小间隙
  逐位不变、2000样本JS对拍仍 PASS → 不解释轮次30漏检、不改既有成绩
- 负结论：B=1 单段认证 P50 22.93/P90 58.43/P99 101.57 ms，432次中225次>20ms；
  自适应宽相位 cap 交错复测耗时无收益，先前1.6×为GPU顺序漂移，已在日志撤回
- 成本模型 L=ceil(log2(bound/(ga+gb)))、查询=2^L+1 与实测对齐（安全段2–17次，未知段33–65次）
- 新增8项段认证测试+1项回放测试（14→23项通过）；变异实测证明张量 max_depth 回绕会误放行

ml/common/kin_torch.py

@@ -38,7 +38,8 @@ def seg_seg_dist(p1, q1, p2, q2, eps=1e-12):
     s = torch.where(t_lo, (-c / a.clamp_min(eps)).clamp(0, 1), s)
     s = torch.where(t_hi, ((b - c) / a.clamp_min(eps)).clamp(0, 1), s)
     t = t.clamp(0, 1)
-    # 退化（线段长度≈0）
+    # 第二条退化成点时，仍须在第一条上投影，而不是固定取其起点。
+    s = torch.where(e <= eps, (-c / a.clamp_min(eps)).clamp(0, 1), s)
     s = torch.where(a <= eps, torch.zeros_like(s), s)
     t = torch.where(e <= eps, torch.zeros_like(t), t)
     c1 = p1 + d1 * s.unsqueeze(-1)
@@ -85,6 +86,25 @@ class Kin:
         gi, gj = self.cap_g[self.pi], self.cap_g[self.pj]
         self.pair_gp = torch.minimum(gi, gj) * 7 + torch.maximum(gi, gj)
         self.lever = T(K['lever'])
+        table = [[0.0] * 7 for _ in range(6)]
+        for group in range(1, 7):
+            endpoints = [c[key] for c in caps if c['g'] == group for key in ('a', 'b')]
+            if not endpoints:
+                continue
+            pivot, axis = K['P'][group - 1], K['D'][group - 1]
+            unit = [v / math.hypot(*axis) for v in axis]
+            relative = [[e[j] - pivot[j] for j in range(3)] for e in endpoints]
+            radius = max(math.hypot(*v) for v in relative)
+            radial = max(math.hypot(v[1] * unit[2] - v[2] * unit[1],
+                                    v[2] * unit[0] - v[0] * unit[2],
+                                    v[0] * unit[1] - v[1] * unit[0]) for v in relative)
+            for joint in range(group):
+                chain = sum(math.dist(K['P'][j], K['P'][j + 1]) for j in range(joint, group - 1))
+                table[joint][group] = (chain + (radial if joint == group - 1 else radius)) * D2R
+        self.cert_groups = torch.tensor([a * 7 + b for a in range(7) for b in range(a + 2, 7)], device=device)
+        # 三角不等式给出全姿态界，不用随机姿态最大值冒充上界。
+        self.cert_lever = T([[table[k][b] if a <= k < b else 0.0 for k in range(6)]
+                             for a in range(7) for b in range(a + 2, 7)])
 
     # ---------------- 运动学 ----------------
     def cum_xf(self, q):
@@ -250,6 +270,56 @@ class Kin:
         gm = gm.scatter_reduce(0, rep_b * len(gp) + self._gp49[self.pair_gp[pidx]], gap.clamp(max=cap), reduce='amin', include_self=True)
         return gm.view(B, len(gp))
 
+    @torch.no_grad()
+    def certify_segments(self, a, b, max_queries=32, max_depth=12, eps=1e-4, cap=20.0, adaptive_cap=True):
+        if self.dtype != torch.float64 or a.dtype != torch.float64 or b.dtype != torch.float64:
+            raise ValueError('segment certification requires float64')
+        # 预算给成张量时 max_depth + 1 会在 uint8 这类窄类型上回绕成 0，循环整个跳过，把碰撞段当安全返回。
+        if type(max_queries) is not int or type(max_depth) is not int:
+            raise ValueError('certification budgets must be plain ints')
+        if max_queries < 2 or max_depth < 0 or eps <= 0 or cap <= eps:
+            raise ValueError('invalid certification budget or tolerance')
+        count = a.shape[0]
+        status = torch.zeros(count, dtype=torch.long, device=a.device)
+        inside = (((a >= self.lo) & (a <= self.hi) & (b >= self.lo) & (b <= self.hi)) | self.cont).all(-1)
+        status[~inside] = 3
+        root = torch.arange(count, device=a.device)
+        gaps = self.gaps(torch.cat([a, b]), cap)['gm'][:, self.cert_groups]
+        ga, gb = gaps[:count], gaps[count:]
+        queries = torch.full((count,), 2, dtype=torch.long, device=a.device)
+        bound = (b - a).abs() @ self.cert_lever.T
+        for depth in range(max_depth + 1):
+            finite = torch.isfinite(ga).all(-1) & torch.isfinite(gb).all(-1)
+            collision = (ga <= 0).any(-1) | (gb <= 0).any(-1)
+            status[root[~finite]] = 2
+            status[root[collision]] = 1
+            positive = (ga > eps).all(-1) & (gb > eps).all(-1)
+            proven = positive & (ga + gb > bound + 2 * eps).all(-1)
+            pending = (status[root] == 0) & ~proven
+            if not bool(pending.any()):
+                break
+            a, b, ga, gb, root, bound = a[pending], b[pending], ga[pending], gb[pending], root[pending], bound[pending]
+            if depth == max_depth:
+                status[root] = 2
+                break
+            requested = torch.bincount(root, minlength=count)
+            status[(status == 0) & (queries + requested > max_queries)] = 2
+            keep = status[root] == 0
+            a, b, ga, gb, root, bound = (t[keep] for t in (a, b, ga, gb, root, bound))
+            if not root.numel():
+                break
+            mid = a + 0.5 * (b - a)
+            # 子段的界是父段一半；宽相位只需覆盖到能被证明的最小间隙，层越深筛得越狠。
+            qc = min(cap, float(bound.max()) / 2 + eps) if adaptive_cap else cap
+            gm = self.gaps(mid, qc)['gm'][:, self.cert_groups]
+            queries += torch.bincount(root, minlength=count)
+            a, b = torch.cat([a, mid]), torch.cat([mid, b])
+            ga, gb = torch.cat([ga, gm]), torch.cat([gm, gb])
+            root = torch.cat([root, root])
+            bound = torch.cat([bound, bound]) / 2
+        return {'safe': status == 0, 'collision': status == 1, 'unresolved': status == 2,
+                'outside_box': status == 3, 'queries': queries}
+
     def min_gap(self, q, cap=40.0):
         return self.gaps(q, cap)['gm'].min(-1).values