@furongjun1999/dsh-memory 0.4.6 → 0.4.8

package/md_cg/bench_en_atoms_public.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""bench_en_atoms_public.py · 双语双路英文原子检索公开复现（2026-09-14）
+
+背景：
+    使用者终局裁定（2026-09-14）：英文检索路线回归双语双路架构——
+    「英文原题 → 英文原子 → Jaccard 直接匹配」（REPRODUCE.md 双语双路裁定）。
+    同日判决：en→zh 词级归一→纯中文库（u2）机械上界 hit@10=33.6%
+    （bench_unified_en 五连探针证据链：归一路 bug=0 / 距离超窗=0 /
+    缺口 100%=题面无词的 8 倍信息差），不再作为英文路线。
+    本脚本是 README「中英双语检索差距」②③ 行的本仓复现入口。
+
+口径（md_cg/semantic/REPRODUCE.md）：
+    doc 侧节点原子集 = 中文五槽条目逐字字级英文映射（lexicon/char_atoms_clean.json，
+    6320 字）∪ 英文正文 normalize_en 归一词 —— 两语素合并为节点原子集合；
+    query 侧两臂：
+      臂②（zh_kw_map）  中文关键词 → 逐字字级英文映射 → normalize_en 词集
+                        （与①共用中文关键词语义链，只换词面编码）
+      臂③（en_query）   英文原题 → normalize_en → 词集（跨过同义改写鸿沟）
+    打分：Jaccard = |q∩d| / |q∪d|（对称归一，eval_common.use_jaccard 同判据），
+    全池 567 节点排序，evidence_turns 任一命中记 hit。
+
+跑法：
+
+    python -m md_cg.bench_en_atoms_public
+
+锚点（README ②③ 行）：
+    ② 96.8 / 99.8 / 99.8（给定中文关键词的检索侧上界）
+    ③ 50.0 / 74.6 / 81.2 · ③a 39.0 / 67.0 / 78.2
+    ④（机械归一端到端下界）英文问句→EN_ZH 词表直译→②同链路
+    ⑤⑥⑦（②路鲁棒性）query 扰动：漏 20% 关键词 / 插 3 噪词 / 错译 20%
+
+诚实边界：
+    1) 池 567 条全为 gold → 零干扰上界，非端到端能力；
+    2) 英文原题来自上游 LoCoMo 派生副本（data/external，不入库）——脚本
+       公开但英文原题自备（BENCH6_EN_QUESTIONS 可覆盖路径）；中文关键词
+       题面在公开集 questions500.jsonl；
+    3) ②的 query 是中文关键词语义链（AI 归一化的输出形态）——AI 归一环节
+       的质量未纳入本评测；④给出机械词表归一的端到端下界作对照；
+    4) ⑤⑥⑦扰动为确定性规则（非随机采样），验证「②路对归一噪声不敏感」，
+       扰动口径见各臂注释。
+"""
+import io
+import json
+import os
+import sys
+import time
+
+HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if HERE not in sys.path:
+    sys.path.insert(0, HERE)
+
+from md_cg import bench6_common as b6            # noqa: E402
+from md_cg import eval_common as ec              # noqa: E402
+from md_cg.mdcg import normalize_en              # noqa: E402
+from md_cg.semantic.en_normalizer import normalize_en_query  # noqa: E402
+
+DATA = b6.DATA
+CORPUS = b6.CORPUS567
+QUESTIONS = b6.QUESTIONS500
+CHAR_ATOMS = os.path.join(HERE, "md_cg", "lexicon", "char_atoms_clean.json")
+
+ZH_RANGE = ("\u4e00", "\u9fff")
+
+# ⑥ 噪词（日常生活中性词，与对话语料存在真实弱共现 → 严苛口径）
+NOISE_ZH = "天气 音乐 旅行"
+# ⑦ 错译池（逐题循环取一组，模拟词表错译 20%）
+WRONG_POOLS = ["经济 历史 音乐", "天体 地理 化学", "科技 法律 医学"]
+
+
+def perturb_kw(text, mode, idx):
+    """②路 query 关键词扰动（确定性规则，验证归一噪声灵敏度）。
+
+    mode=drop20   每 5 词丢 1（位置随题号错位，模拟归一漏词 20%）
+    mode=noise3   尾部插 3 个固定噪词（模拟归一混入无关概念）
+    mode=wrong20  每 5 词错译 1（固定错译池循环，模拟词表错译 20%）
+    """
+    words = [w for w in (text or "").split() if w]
+    if not words:
+        return text or ""
+    if mode == "drop20":
+        return " ".join(w for i, w in enumerate(words) if (i + idx) % 5 != 0)
+    if mode == "noise3":
+        return " ".join(words + NOISE_ZH.split())
+    if mode == "wrong20":
+        pool = WRONG_POOLS[idx % len(WRONG_POOLS)].split()
+        return " ".join(pool[i % len(pool)] if (i + idx) % 5 == 0 else w
+                        for i, w in enumerate(words))
+    return text
+
+
+def load_char_atoms():
+    """字级英文原子库：{中文字: 英文短语}。"""
+    with io.open(CHAR_ATOMS, encoding="utf-8") as f:
+        data = json.load(f)
+    lex = data.get("lexicon") or {}
+    return {ch: str(v.get("en") or "") for ch, v in lex.items()}
+
+
+def zh_map_en(text, char_atoms):
+    """中文逐字→英文短语映射串；英文/数字原样保留（交 normalize_en 归一）。"""
+    lo, hi = ZH_RANGE
+    parts = []
+    for ch in (text or ""):
+        if lo <= ch <= hi:
+            parts.append(char_atoms.get(ch, ""))
+        else:
+            parts.append(ch)
+    return normalize_en(" ".join(parts))
+
+
+def node_atom_set(c, char_atoms, body_only=False):
+    """doc 侧节点原子集：中文五槽字级映射 ∪ 英文正文归一词（双语双路 doc 侧）。
+
+    body_only=True 时只取英文正文归一词——「英文原子直接匹配」最纯形态
+    （使用者产品口径：英文 query → 英文原子 → 英文原子库 → 返回英文原文）。
+    """
+    toks = normalize_en(str(c.get("text") or "")).split()
+    if not body_only:
+        toks += zh_map_en(str(c.get("zh") or ""), char_atoms).split()
+    return frozenset(toks)
+
+
+def jaccard(a, b):
+    if not a or not b:
+        return 0.0
+    inter = len(a & b)
+    return inter / len(a | b) if inter else 0.0
+
+
+def round_dict(st):
+    return {k: round(v, 1) for k, v in st.items()}
+
+
+def run_arm(questions, docs, qatoms_of, label):
+    """单臂评测：全池 Jaccard 排序，hit@1/5/10 + MRR。"""
+    st = {"h1": 0, "h5": 0, "h10": 0, "rr": 0.0, "n": 0}
+    for q in questions:
+        ev = set(q.get("evidence_turns") or [])
+        qa = qatoms_of(q)
+        if not qa:
+            st["n"] += 1
+            continue
+        scored = sorted(((jaccard(qa, na), nid) for nid, na in docs),
+                        key=lambda t: (-t[0], t[1]))
+        rank = next((r for r, (s, nid) in enumerate(scored, 1) if nid in ev), 0)
+        st["n"] += 1
+        if rank == 1:
+            st["h1"] += 1
+        if 0 < rank <= 5:
+            st["h5"] += 1
+        if 0 < rank <= 10:
+            st["h10"] += 1
+        if rank:
+            st["rr"] += 1.0 / rank
+    n = max(st["n"], 1)
+    print("  %-14s hit@1=%5.1f%%  hit@5=%5.1f%%  hit@10=%5.1f%%  MRR=%.4f  (n=%d)"
+          % (label, st["h1"] * 100.0 / n, st["h5"] * 100.0 / n,
+             st["h10"] * 100.0 / n, st["rr"] / n, st["n"]))
+    return {k: (v / n if k == "rr" else v * 100.0 / n) for k, v in st.items()}
+
+
+def main():
+    t0 = time.time()
+    with io.open(CORPUS, encoding="utf-8") as f:
+        corpus = [json.loads(ln) for ln in f if ln.strip()]
+    with io.open(QUESTIONS, encoding="utf-8") as f:
+        questions = [json.loads(ln) for ln in f if ln.strip()]
+    char_atoms = load_char_atoms()
+    docs = [(c["id"], node_atom_set(c, char_atoms)) for c in corpus]
+    docs_body = [(c["id"], node_atom_set(c, char_atoms, body_only=True))
+                 for c in corpus]
+    print("[en_atoms] locomo-zh-500 · 语料 %d / 题 %d · 字级原子 %d 字"
+          % (len(corpus), len(questions), len(char_atoms)))
+
+    # 臂② 中文关键词 → 字级英文原子（与①共用语义链，只换词面编码）
+    r2 = run_arm(questions, docs,
+                 lambda q: frozenset(zh_map_en(str(q.get("question") or ""),
+                                               char_atoms).split()),
+                 "② zh→en atoms")
+    # 臂③ 英文原题 → 归一化英文原子（跨同义改写鸿沟）
+    # 英文原题行字段=question（raw_questions.jsonl，上游派生不入库）
+    en_rows = {r.get("qid"): str(r.get("question") or "")
+               for r in ec.iter_jsonl(b6.EN_QUESTIONS)}
+    en_q = lambda q: frozenset(normalize_en(          # noqa: E731
+        en_rows.get(q.get("qid"), "")).split())
+    r3 = run_arm(questions, docs, en_q, "③ en query")
+    # 臂③a 纯英文正文直接匹配（产品最纯形态：doc=英文正文原子，无加工面辅助）
+    r3a = run_arm(questions, docs_body, en_q, "③a en·body")
+    # 臂④ 机械归一端到端下界：英文问句 → 词表直译为中文词（CEDICT 28294 键
+    #     ∪ EN_ZH 手工层，无 AI）→ ②同链路。与②唯一差异 = query 归一来源：
+    #     ②=AI 理解式归一的输出形态（标注关键词），④=机械查表归一。
+    def e4(q):
+        terms, _ = normalize_en_query(en_rows.get(q.get("qid"), ""))
+        return frozenset(zh_map_en(" ".join(terms), char_atoms).split())
+    r4 = run_arm(questions, docs, e4, "④ en→zh·mech")
+    # 臂⑤⑥⑦ ②路鲁棒性：query 关键词确定性扰动后走同一 ② 链路
+    zh_q = lambda q: str(q.get("question") or "")  # noqa: E731
+    r5 = run_arm(questions, docs,
+                 lambda q: frozenset(zh_map_en(
+                     perturb_kw(zh_q(q), "drop20", questions.index(q)),
+                     char_atoms).split()), "⑤ ②-20%kw")
+    r6 = run_arm(questions, docs,
+                 lambda q: frozenset(zh_map_en(
+                     perturb_kw(zh_q(q), "noise3", questions.index(q)),
+                     char_atoms).split()), "⑥ ②+3noise")
+    r7 = run_arm(questions, docs,
+                 lambda q: frozenset(zh_map_en(
+                     perturb_kw(zh_q(q), "wrong20", questions.index(q)),
+                     char_atoms).split()), "⑦ ②20%wrong")
+
+    print("[en_atoms] 完成（%.0fs）②=%s ③=%s ③a=%s ④=%s ⑤=%s ⑥=%s ⑦=%s"
+          % (time.time() - t0,
+             *(round_dict(r) for r in (r2, r3, r3a, r4, r5, r6, r7))))
+    print("  锚点：② 96.8/99.8/99.8（给定关键词上界） · ③ 81.2 · ④ 机械下界"
+          " · ⑤⑥⑦ 鲁棒性（hit@10 应稳 99+）")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/md_cg/bench_membench.py

@@ -297,10 +297,14 @@ def patch_random_path(cg, seed=0):
 
 
 def patch_symmetric_pool(cg):
-    """让 lexical 与 fuzzy 看到同样的全量候选池（消除 GLOBAL_CAP 截断偏置）。
+    """【2026-09-16 起已冗余】抬高 GLOBAL_CAP，让 lexical 与 fuzzy 候选池对称。
 
-    lexical 命中数超过 GLOBAL_CAP 时按**插入序**截断；fuzzy 则全库打分后取 Top-50。
-    两条路的候选池不对称，会系统性偏袒 fuzzy。抬高 cap 使其对等。
+    背景：lexical 命中数超 GLOBAL_CAP 时按**插入序**截断，fuzzy 则全库打分后取
+    Top-50；两条路候选池不对称，会系统性偏袒 fuzzy。当时以「抬高 cap」对冲。
+
+    现状：截断依据已改为**相关度**（`mdcg.cut_by_relevance` 与 `mdcos._lexical`
+    均先全量打分再排序截断，cap 值仍为 500）——插入序偏置的根因已消除，本 patch
+    不再必要。保留仅为兼容既有对照命令（`--symmetric-pool`）与历史口径复现。
     """
     from md_cg import mdcos as _m
     _m.GLOBAL_CAP = 10 ** 9
@@ -310,8 +314,9 @@ def patch_symmetric_pool(cg):
 def patch_lexical_full(cg):
     """让 lexical 也对**全量候选池**打分（消除「扫描范围」差异，只留排序算法差异）。
 
-    默认 _lexical 只在 LIKE 命中集上打分（中位约 20 条），而 _path_fuzzy 扫全库 1000 条；
-    仅抬高 GLOBAL_CAP 只修好「LIKE 全空」的兜底分支，非空命中时池仍不对等。
+    默认 _lexical 只在 LIKE 命中集上打分（中位约 20 条），而 _path_fuzzy 扫全库 1000 条。
+    注：截断依据改为相关度后（2026-09-16），「排序依据不对等」已消除，此处差异
+    仅剩**扫描范围**一项；本 patch 仍用于隔离排序算法差异的对照实验。
     """
     from md_cg.mdcg import bigrams
 

package/md_cg/bench_progressive.py

@@ -0,0 +1,276 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""bench_progressive.py · 渐进式语义检索双实验（2026-09-14）
+
+理论（使用者与 GPT 定稿）：查询不是固定语义结构，而是不断收紧的约束集合；
+从最小可靠语义开始宽检索，再按区分度逐步增加条件使语义收敛。
+「语义解析的完整性与检索的必要性不是同一个问题。」
+
+实验一（locomo-zh-500 · 原子面，与 bench_en_atoms_public 同 doc 侧口径）：
+  G0 一次性全原子      —— 对照锚点（应 ≈ ② 96.8/99.8/99.8，同口径自校验）
+  G2 只宽检不细化      —— core 50% 一次性排序（「最小可靠语义」本身水平）
+  G1 渐进              —— Stage-1 宽检索 → 区分度引导加原子 → 重排
+                          （max_stages=4；每阶段都被测量）
+  统计：initial（Stage-1）/ final（终态）hit@1/5/10+MRR、平均 refinement
+  steps（added 条件数）、一步收敛率。
+  诚实边界：池 567 全 gold 零干扰——G1≈G0 属预期（⑤⑥⑦已证宽检索
+  鲁棒）；本实验量化「渐进不劣于一次性 + 步数可观测」，消歧增益见实验二。
+
+实验二（受控干扰池 · 引擎侧，42+2 节点真实 MdCGOS）：
+  在 test_sem_noise 语料上放 2 条条件冒充邻居（正条件与 gold 同款 →
+  judge 判 ACCEPT）——构造 False ACCEPT>0 的形态；渐进循环：
+  宽检索 → discriminative 在候选间选区分性条件词 → 带条件重排。
+  断言：渐进后 False ACCEPT=0 且 top1 ∈ gold——
+  「DEFER/冒充不是终点，加条件后语义收敛」的引擎侧实证。
+  条件词池本轮手工给定（示教）；真实系统应由 atoms.json 标准词表驱动。
+
+跑法：python -m md_cg.bench_progressive
+"""
+import io
+import json
+import os
+import shutil
+import sys
+import tempfile
+import time
+
+HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if HERE not in sys.path:
+    sys.path.insert(0, HERE)
+
+from md_cg import bench6_common as b6                        # noqa: E402
+from md_cg.bench_en_atoms_public import (                    # noqa: E402
+    CORPUS, QUESTIONS, jaccard, load_char_atoms, node_atom_set,
+    round_dict, zh_map_en)
+from md_cg.mdcos import MdCGOS                               # noqa: E402
+from md_cg.progressive import discriminative, progressive_search  # noqa: E402
+from md_cg.test_sem_noise import (                           # noqa: E402
+    GOLD, GOLD_COND, NEG_TEXTS, NEIGHBORS, QUERY, UNREL_DOCS, _doc)
+
+
+def rank_of(ev, ids):
+    """gold 在 id 排名中的位次（不在则 0）。"""
+    return next((r for r, nid in enumerate(ids, 1) if nid in ev), 0)
+
+
+def _agg(rank, st):
+    if rank == 1:
+        st["h1"] += 1
+    if 0 < rank <= 5:
+        st["h5"] += 1
+    if 0 < rank <= 10:
+        st["h10"] += 1
+    if rank:
+        st["rr"] += 1.0 / rank
+
+
+def _show(label, st, n, extra=""):
+    print("  %-22s hit@1=%5.1f%%  hit@5=%5.1f%%  hit@10=%5.1f%%  "
+          "MRR=%.4f%s" % (label, st["h1"] * 100.0 / n,
+                          st["h5"] * 100.0 / n, st["h10"] * 100.0 / n,
+                          st["rr"] / n, extra))
+
+
+def full_rank(qa, docs):
+    """全池 Jaccard 排序 → id 序列（与 run_arm 同判据）。"""
+    scored = sorted(((jaccard(qa, na), nid) for nid, na in docs),
+                    key=lambda t: (-t[0], t[1]))
+    return [nid for _s, nid in scored]
+
+
+def exp_locomo():
+    """实验一：原子面渐进三形态。"""
+    t0 = time.time()
+    with io.open(CORPUS, encoding="utf-8") as f:
+        corpus = [json.loads(ln) for ln in f if ln.strip()]
+    with io.open(QUESTIONS, encoding="utf-8") as f:
+        questions = [json.loads(ln) for ln in f if ln.strip()]
+    char_atoms = load_char_atoms()
+    docs = [(c["id"], node_atom_set(c, char_atoms)) for c in corpus]
+    docs_map = dict(docs)
+    print("[progressive] 实验一 locomo-zh-500 · 语料 %d / 题 %d"
+          % (len(corpus), len(questions)))
+
+    pool_sizes = []                        # G1 各阶段候选池大小（统计面）
+
+    def rank_fn(used):
+        ranked = full_rank(frozenset(used), docs)[:20]
+        pool_sizes.append(len(ranked))
+        return [(nid, 0.0) for nid in ranked]
+
+    st_g0 = {"h1": 0, "h5": 0, "h10": 0, "rr": 0.0}
+    st_g2 = dict(st_g0)
+    st_i = dict(st_g0)
+    st_f = dict(st_g0)
+    steps_sum = conv = n = fa10_sum = 0
+    for q in questions:
+        ev = set(q.get("evidence_turns") or [])
+        qa = [w for w in zh_map_en(str(q.get("question") or ""),
+                                   char_atoms).split() if w]
+        if not qa:
+            continue
+        n += 1
+        # G0 一次性全原子（对照锚点）
+        _agg(rank_of(ev, full_rank(frozenset(qa), docs)), st_g0)
+        # G2 只宽检不细化
+        core = qa[:max(1, int(len(qa) * 0.5))]
+        _agg(rank_of(ev, full_rank(frozenset(core), docs)), st_g2)
+        # G1 渐进
+        tr = progressive_search(rank_fn, qa, docs_map,
+                                ratio=0.5, k=10, max_stages=4)
+        _agg(rank_of(ev, full_rank(frozenset(tr["stages"][0]["used"]),
+                                   docs)), st_i)
+        fin_all = full_rank(frozenset(tr["stages"][-1]["used"]), docs)
+        _agg(rank_of(ev, fin_all), st_f)
+        # 保守 false_accept 口径：final top10 内非 gold 条数（本语料无资格
+        # 判定面，非 gold 全计为假接受——上界，见打印行口径注明）
+        fa10_sum += sum(1 for nid in fin_all[:10] if nid not in ev)
+        steps_sum += len(tr["added"])
+        conv += 1 if (tr["converged"] or len(tr["added"]) < 3) else 0
+
+    _show("G0 一次性全原子", st_g0, n,
+          "   ← 锚点应≈② 96.8/99.8/99.8")
+    _show("G2 只宽检(core50%)", st_g2, n)
+    _show("G1 渐进·initial", st_i, n)
+    _show("G1 渐进·final", st_f, n)
+    print("  refinement: 平均加条件数=%.2f  一步收敛率=%.1f%%  (n=%d, %.0fs)"
+          % (steps_sum / max(n, 1), conv * 100.0 / max(n, 1), n,
+             time.time() - t0))
+    print("  false_accept(保守口径)=%.2f%%  =G1 final top10 非 gold 平均占比"
+          "（上界：本语料无 CCG 注释面，非 gold 全计为假接受）"
+          % (fa10_sum * 10.0 / max(n, 1)))
+    print("  候选池: G1 各阶段平均 top 池大小=%.1f (k=20 上限)"
+          % (sum(pool_sizes) / max(len(pool_sizes), 1)))
+    print("  四态分布: 本实验为原子面（语料无 CCG 注释，judge_qualification "
+          "将全判 BLINDSPOT）——资格判定不适用，不硬造数字；四态实证见实验二")
+    return {"g0": st_g0, "g2": st_g2, "g1i": st_i, "g1f": st_f, "n": n,
+            "fa10_conservative": fa10_sum * 10.0 / max(n, 1),
+            "avg_pool": sum(pool_sizes) / max(len(pool_sizes), 1)}
+
+
+def exp_controlled():
+    """实验二：受控干扰池——条件冒充形态下渐进消歧（引擎侧真检索）。"""
+    print("\n[progressive] 实验二 受控干扰池（42+2 节点真实 MdCGOS）")
+    tmp = tempfile.mkdtemp(prefix="mdcg_prog_")
+    try:
+        root = os.path.join(tmp, "root")
+        cg = MdCGOS(root)
+        gold_ids = [g for g, _ in GOLD]
+        for gid, fact in GOLD:
+            cg.add(gid, _doc(fact, GOLD_COND), layer="knowledge",
+                   verification_basis="test")
+        # 2 条邻居改用 gold 同款生效条件 → 正条件命中 → judge 判 ACCEPT（冒充）
+        IMPOSTORS = ("n1a", "n3a")
+        for gid, lst in NEIGHBORS.items():
+            for nid, fact, _cond in lst:
+                cg.add(nid, _doc(fact, GOLD_COND if nid in IMPOSTORS
+                                 else _cond), layer="knowledge",
+                       verification_basis="test")
+        for nid, fact in NEG_TEXTS:
+            cg.add(nid, _doc(fact, "问没做的事", extra_neg=True),
+                   layer="knowledge", verification_basis="test",
+                   non_applicable_conditions=["刚才在干什么"])
+        for nid, fact, cond in UNREL_DOCS:
+            cg.add(nid, _doc(fact, cond), layer="knowledge",
+                   verification_basis="test")
+
+        KW = dict(paths=("lexical", "bucket", "entity", "graph", "fuzzy"),
+                  fusion="sum", judge_ranking=True)
+
+        def engine_rank(used):
+            res, _m = cg.search_rrf(QUERY + (" " + " ".join(used)
+                                             if used else ""),
+                                    k=10, judge=True, **KW)
+            return [(r[0]["id"], r[1]) for r in res]
+
+        def false_accepts(res):
+            out = []
+            for r in res[:10]:
+                nid = r[0]["id"]
+                if nid in gold_ids:
+                    continue
+                ji = r[2] if len(r) > 2 else {}
+                if (ji or {}).get("state") == "ACCEPT":
+                    out.append(nid)
+            return out
+
+        def state_dist(res):
+            """渐进循环四态分布（top10 内 judge state 计数，只列非零项）。
+
+            judge info 直接复用 search_rrf(judge=True) 注入的
+            judge_qualification 产物（结果第三元），不重复判定。
+            """
+            d = {"ACCEPT": 0, "DEFER": 0, "REJECT": 0, "BLINDSPOT": 0,
+                 "无judge": 0}
+            for r in res[:10]:
+                st = (r[2] or {}).get("state") if len(r) > 2 else None
+                d[st if st in d else "无judge"] += 1
+            return {k: v for k, v in d.items() if v}
+
+        def fa_rate(res, fa):
+            return 100.0 * len(fa) / max(1, min(10, len(res)))
+
+        # 宽检索（不加任何条件；judgeinfo 直接取 results 第三元）
+        wide_res, _m = cg.search_rrf(QUERY, k=10, judge=True, **KW)
+        wide = [(r[0]["id"], r[1]) for r in wide_res]
+        fa_pre = false_accepts(wide_res)
+        top1_pre = wide[0][0] if wide else None
+        print("  宽检索 top1=%s  top10 内 False ACCEPT=%s（率=%.1f%%）"
+              % (top1_pre, fa_pre or "无", fa_rate(wide_res, fa_pre)))
+        print("  四态分布(宽检索 top10)=%s  候选池=%d  judge 剔除=%s"
+              % (state_dist(wide_res), len(wide_res),
+                 (_m or {}).get("judge_filtered", 0)))
+
+        # 渐进：候选间区分性条件词 → 带条件重排
+        POOL = ["我", "喝水", "吃饭", "电脑", "书", "音乐", "出门",
+                "浇花", "下班"]
+        cand_chars = {}
+        for r in wide_res[:10]:
+            nid = r[0]["id"]
+            cand_chars[nid] = frozenset(str(r[0].get("content") or ""))
+        cond = discriminative([p for p in POOL],
+                              [cand_chars.get(nid, frozenset())
+                               for nid, _s in wide[:10]])
+        if cond:
+            refined_res, _m2 = cg.search_rrf(QUERY + " " + cond,
+                                             k=10, judge=True, **KW)
+            fa_post = false_accepts(refined_res)
+            top1_post = refined_res[0][0]["id"] if refined_res else None
+            print("  区分性条件=%r → 重排 top1=%s  top10 内 "
+                  "False ACCEPT=%s（率=%.1f%%）"
+                  % (cond, top1_post, fa_post or "无",
+                     fa_rate(refined_res, fa_post)))
+            print("  四态分布(重排 top10)=%s  候选池=%d  judge 剔除=%s"
+                  % (state_dist(refined_res), len(refined_res),
+                     (_m2 or {}).get("judge_filtered", 0)))
+            ok1 = top1_post in gold_ids
+            no_new = set(fa_post) <= set(fa_pre)
+            print("  断言①渐进后 top1∈gold：%s" % ("PASS" if ok1 else "FAIL"))
+            print("  断言②渐进不引入新冒充（fa_post⊆fa_pre）：%s"
+                  % ("PASS" if no_new else "FAIL"))
+            if fa_post:
+                for r in refined_res[:10]:
+                    if r[0]["id"] in fa_post and len(r) > 2:
+                        print("    冒充 %s judge reason：%s"
+                              % (r[0]["id"],
+                                 (r[2] or {}).get("reason", "")))
+            print("  边界（如实）：条件面冒充（生效条件被伪造为 gold 同款）"
+                  "不被内容词渐进消除——词面条件确认是必要非充分，"
+                  "真伪判据=verification_basis/时间线冲突（证据强度分离，另案）")
+            return ok1 and no_new
+        print("  无区分性条件可选（宽检索已无冒充）——如实记录")
+        return not fa_pre
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def main():
+    exp_locomo()
+    ok = exp_controlled()
+    print("\n[progressive] 完成。受控池消歧断言：%s"
+          % ("PASS" if ok else "FAIL"))
+    return 0 if ok else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())