diff --git a/doc/roadmap/blind-experiment-2026-09-23-deepseek-flash.md b/doc/roadmap/blind-experiment-2026-09-23-deepseek-flash.md new file mode 100644 index 0000000..c79f83f --- /dev/null +++ b/doc/roadmap/blind-experiment-2026-09-23-deepseek-flash.md @@ -0,0 +1,34 @@ +# 盲测实验(§5.2(b) 查询式 vs 全文档背诵)—— 2026-09-23 + +| | | +|---|---| +| 模型 | `deepseek-flash` @ `https://llm.cflmy.cn/v1` | +| 样本 | 6 任务(业务 3 + QuixBugs 改写 3),oracle = stdout 精确匹配 | +| 协议 | 系统提示词 = 硬规则 12 条 + 契约表三形状(两臂同文);**唯一变量 = 语法来源**:`query` 臂 MLSP 查询通道(≤3 次)vs `docs` 臂完整 markup 参考(背诵) | +| 修复 | validate 诊断 + stderr 回喂,≤2 次修复;temperature=0,max_tokens=8000 | + +## 汇总(判据:Q 通过率不劣于 D;首轮语法错误率 Q≤D;token Q≤70%%D;轮次不升) + +| 臂 | 通过(一轮) | 通过(最终≤3) | 首轮语法错误 | 首轮契约诊断 | 平均修复轮(过例) | token 合计(prompt+completion) | 弃权/基础设施 | +|---|---|---|---|---|---|---|---| +| query | 0/3 | 0/3 | 2/3 | 1/3 | 0.00 | 69771(42478+27293) | 3 | +| docs | 3/6 | 4/6 | 2/6 | 0/6 | 0.50 | 57276(33346+23930) | 0 | + +## 逐例 + +| 例 | 臂 | 结果 | 修复轮 | 首轮语法错 | 首轮契约诊断 | token(p+c) | 查询 | 备注 | +|---|---|---|---|---|---|---|---|---| +| claims_reserve_settle | query | load-fail | 0 | 是 | 否 | 11987+8177 | 3 | {"error":{"code":"mlsp.parse_error","message":": trailing input in expression: \"(claim - deductible, 0)\""},"id":1,"ok":false} \| stderr=error: /tmp/marqdo_blind_1694593_query_claims_reserve_settle.mq.md: trailing input in expression: "(claim - deductible, 0)" | +| contract_milestone_pay | query | infra | 0 | 否 | 否 | 3970+4718 | 3 | 非 JSON / 空体: | +| vendor_po_gate | query | load-fail | 0 | 是 | 否 | 9552+3686 | 3 | 回复中无程序 \| 开头: QUERY: 条件分支 写法 | +| qb_gcd | query | run-fail | 0 | 否 | 是 | 9700+8488 | 3 | \| stderr=error: /tmp/marqdo_blind_1694593_query_qb_gcd.mq.md:26:1: unknown function `gcd(48` | +| qb_max_sublist_sum | query | infra | 0 | 否 | 否 | 1253+134 | 3 | 非 JSON / 空体: | +| qb_get_factors | query | infra | 0 | 否 | 否 | 6016+2090 | 3 | 非 JSON / 空体: | +| claims_reserve_settle | docs | pass | 0 | 否 | 否 | 2699+2987 | 0 | queries=0 | +| contract_milestone_pay | docs | pass | 0 | 否 | 否 | 2800+3202 | 0 | queries=0 | +| vendor_po_gate | docs | pass | 0 | 否 | 否 | 2690+1264 | 0 | queries=0 | +| qb_gcd | docs | pass | 2 | 否 | 否 | 8147+6970 | 0 | queries=0 | +| qb_max_sublist_sum | docs | run-fail | 0 | 是 | 否 | 8518+3609 | 0 | \| stderr=error: /tmp/marqdo_blind_1694593_docs_qb_max_sublist_sum.mq.md:3:1: unknown function `[-2,` | +| qb_get_factors | docs | run-fail | 0 | 是 | 否 | 8492+5898 | 0 | \| stderr=error: /tmp/marqdo_blind_1694593_docs_qb_get_factors.mq.md:20:1: missing argument for parameter `value` | + +报告由 `tests/blind_experiment.rs` 生成;材料冻结于 `tests/blind/`(任务书 + docs-bundle),判据见 `doc/roadmap/perf-validation.md` §2。 diff --git a/doc/roadmap/blind-experiment-2026-09-23-mimo-v2.6-pro.md b/doc/roadmap/blind-experiment-2026-09-23-mimo-v2.6-pro.md new file mode 100644 index 0000000..fe33edc --- /dev/null +++ b/doc/roadmap/blind-experiment-2026-09-23-mimo-v2.6-pro.md @@ -0,0 +1,34 @@ +# 盲测实验(§5.2(b) 查询式 vs 全文档背诵)—— 2026-09-23 + +| | | +|---|---| +| 模型 | `mimo-v2.6-pro` @ `https://llm.cflmy.cn/v1` | +| 样本 | 6 任务(业务 3 + QuixBugs 改写 3),oracle = stdout 精确匹配 | +| 协议 | 系统提示词 = 硬规则 12 条 + 契约表三形状(两臂同文);**唯一变量 = 语法来源**:`query` 臂 MLSP 查询通道(≤3 次)vs `docs` 臂完整 markup 参考(背诵) | +| 修复 | validate 诊断 + stderr 回喂,≤2 次修复;temperature=0,max_tokens=8000 | + +## 汇总(判据:Q 通过率不劣于 D;首轮语法错误率 Q≤D;token Q≤70%%D;轮次不升) + +| 臂 | 通过(一轮) | 通过(最终≤3) | 首轮语法错误 | 首轮契约诊断 | 平均修复轮(过例) | token 合计(prompt+completion) | 弃权/基础设施 | +|---|---|---|---|---|---|---|---| +| query | 0/0 | 0/0 | 0/0 | 0/0 | 0.00 | 8011(6566+1445) | 6 | +| docs | 0/0 | 0/0 | 0/0 | 0/0 | 0.00 | 0(0+0) | 6 | + +## 逐例 + +| 例 | 臂 | 结果 | 修复轮 | 首轮语法错 | 首轮契约诊断 | token(p+c) | 查询 | 备注 | +|---|---|---|---|---|---|---|---|---| +| claims_reserve_settle | query | infra | 0 | 否 | 否 | 1424+366 | 3 | 非 JSON / 空体: | +| contract_milestone_pay | query | infra | 0 | 否 | 否 | 1528+381 | 1 | 非 JSON / 空体: | +| vendor_po_gate | query | infra | 0 | 否 | 否 | 0+0 | 0 | 非 JSON / 空体: | +| qb_gcd | query | infra | 0 | 否 | 否 | 1211+252 | 3 | 非 JSON / 空体: | +| qb_max_sublist_sum | query | infra | 0 | 否 | 否 | 1216+226 | 3 | 非 JSON / 空体: | +| qb_get_factors | query | infra | 0 | 否 | 否 | 1187+220 | 3 | 非 JSON / 空体: | +| claims_reserve_settle | docs | infra | 0 | 否 | 否 | 0+0 | 0 | 非 JSON / 空体: | +| contract_milestone_pay | docs | infra | 0 | 否 | 否 | 0+0 | 0 | 非 JSON / 空体: | +| vendor_po_gate | docs | infra | 0 | 否 | 否 | 0+0 | 0 | 非 JSON / 空体: | +| qb_gcd | docs | infra | 0 | 否 | 否 | 0+0 | 0 | 非 JSON / 空体: | +| qb_max_sublist_sum | docs | infra | 0 | 否 | 否 | 0+0 | 0 | 非 JSON / 空体: | +| qb_get_factors | docs | infra | 0 | 否 | 否 | 0+0 | 0 | 非 JSON / 空体: | + +报告由 `tests/blind_experiment.rs` 生成;材料冻结于 `tests/blind/`(任务书 + docs-bundle),判据见 `doc/roadmap/perf-validation.md` §2。 diff --git a/doc/roadmap/perf-validation-report-2026-09-23.md b/doc/roadmap/perf-validation-report-2026-09-23.md new file mode 100644 index 0000000..e9e5105 --- /dev/null +++ b/doc/roadmap/perf-validation-report-2026-09-23.md @@ -0,0 +1,118 @@ +# P4 验证汇总报告 — 2026-09-23 + +> 执行 [perf-validation.md](perf-validation.md)(自设计性能验证协议)的结果汇总。 +> 覆盖 three-problems.md 三大问题的**验证矩阵**(§5.2 a–e)。逐例明细见各实验原始报告(文末索引)。 + +| | | +|---|---| +| 协议 | [perf-validation.md](perf-validation.md)(实验 (a)–(e)) | +| 判据源 | [three-problems.md](three-problems.md) §3.7 / 各问题 §2.4 | +| 构建 | marqdo v1.0.7(本仓库工作树;金 20 + 全量回归通过后采样) | +| 端点 | `llm.cflmy.cn/v1`(OpenAI 兼容;temperature=0) | +| 模型 | 修复实验:`cflmy`、`mimo-v2.6-flash`;盲测:`deepseek-flash`、`mimo-v2.6-pro`(按用户指定) | +| 回归 | 全量干净回归(无 API key 基线)**零失败** | + +## 1. 五实验结果与判据对照 + +| 实验 | 判据 | 结果 | 判定 | +|---|---|---|---| +| **(a) 锚点消融**(T3.3,双模型×20例×双臂,三轮) | anchor 臂一轮修复率 ≥ 80%;护栏 0 次越界应用 | cflmy anchor **20/20=100%**(plain 17/20=85%);mimo-v2.6-flash anchor **20/20=100%**(plain 18/20=90%;容错加固中的第二轮 anchor 18/20=90% 亦 ≥80%);越界拒/越界应用 0/0 | ✅ 过 | +| **(b) 盲测**(查询式 vs 全文档背诵,6任务×2臂) | 四判据:最终通过率 Q 不劣于 D(允许 −0 例);首轮语法错误率 Q ≤ D;平均修复轮次 Q ≤ D;token ≤ 70% of D(首轮契约诊断率为观测项) | deepseek-flash:docs 4/6 vs query 0/3(3 例端点 infra 剔除);首轮语法错 2/3 vs 2/6;token 69,771 vs 57,276。mimo-v2.6-pro:首跑 12/12 端点 infra,单独重跑见 §3 | ❌ 四判据未全立 ⇒ 按 §3.7 继续改协议 | +| **(c) 契约消融**(四边界×三情形) | 带契约错值拦截 = 100%;带契约对值误报 = 0%;无契约路径零回归 | 拦截 4/4=**100%**;误报 0/4=**0%**;无契约 4/4 动态语义保持(含 `missing map key` 基线) | ✅ 过 | +| **(d) 防漂移演练**(9 漂移 + 2 负对照) | 故意写错必报 = 100%;对照组误报 = 0% | 必报 9/9=**100%**(`unknown_type`×2、`param_drift`×2、`return_mismatch`、`arg_mismatch`、`unknown_key`、`contract.duplicate`、`contract.unknown_table`);负对照误报 0/2 | ✅ 过 | +| **(e) 核心守卫演练**(3 种变异注入) | 单边改动必红;还原必绿 | 3/3 必红(`CORE_CONSTRUCTS` 私增、`core-surface.md` 私增、金样删除);还原全绿 | ✅ 过 | + +**可复制结论(a/c/d/e 全过)**:锚点臂一轮修复率双模型 100%(判据 ≥80%,增量 +15pp/+10pp——易锚定样本近天花板,区分性留难样本扩展);契约系统"只在声明处拦截、零误报、不碰动态路径"成立;契约/实现互查防漂移 100% 必报;核心面单边膨胀被 CI 守卫机械阻断。 + +## 2. 实验 (c)(d)(e) 明细 + +### (c) 契约消融(tests/contract_ablation.rs,确定性) + +四边界(调用实参 / 返回值 / 表绑定 / 键访问)各测三情形: + +| 情形 | 口径 | 结果 | +|---|---|---| +| ① 带契约 + 错值 | 必须拦截(`contract.arg_mismatch` / `contract.return_mismatch` / `contract.field_mismatch` / `contract.unknown_key`) | 4/4 | +| ② 带契约 + 对值 | 不得报契约错(同路径同形状) | 0/4 误报 | +| ③ 无契约 + 错值 | 保持动态语义(不得出现 `contract.*`;走经典动态错误如 `missing map key`) | 4/4 | + +取元一律用主推的 `[]()` 形(`[键](`集合`)`)验证;`集合[^键]` 过渡形保留兼容金样覆盖。 + +### (d) 防漂移演练(tests/drift_drill.rs,确定性) + +9 个"故意写错"全部必报:类型词拼错、参数名漂移、升参未覆盖、返回越约、实参越约、未知键、重复契约表、错列表头契约表、运行时值越约。负对照 2 例(被绑定的数据表、纯动态程序)零误报。同时验证"契约表一经出现即为完整声明"(新升参未覆盖 ⇒ `contract.param_drift` warning)被按设计触发。 + +### (e) 核心守卫演练(人工变异,tests/core_surface.rs 必红验证) + +| 变异 | 注入点 | 结果 | +|---|---|---| +| 私增 `ghost-construct` | `src/parse/mod.rs` `CORE_CONSTRUCTS` | 🔴 必红 | +| 私增 `ghost-construct` 行 | `doc/design/core-surface.md` | 🔴 必红 | +| 删除金样文件 | `tests/markup-v03/soft-emphasis.mq.md` | 🔴 必红 | + +三次还原后 🟢 全绿。CI 守卫强制"清单与文档双改 + 全部金样存在"。 + +## 3. 实验 (b) 盲测:详况与诚实结论 + +### 协议 + +两臂系统提示词同文 = 硬规则 12 条 + 契约表三形状;**唯一变量 = 语法知识获取**: + +- `query` 臂:MLSP 查询通道(`QUERY: <关键字>` ⇒ `mlsp syntax` 卡片,含戒律原文/样例/文档锚点;≤3 次) +- `docs` 臂:完整 markup 参考背诵(`tests/blind/docs-bundle.md`,背诵式全语法表 + 中文内建面) + +任务 6 例(`tests/blind/tasks/`):业务 3(保险理赔准备金 / 工程进度款 / 采购付款门槛,均出自律所实测任务集)+ QuixBugs 改写 3(gcd / 最大子段和 / 质因数分解);oracle = stdout 精确匹配(任务书自带期望输出,把推理难度控制掉,失败归因于**语言能力**)。修复回路 ≤2 次(validate 结构化诊断 + stderr 回喂)。 + +### deepseek-flash(完成) + +| 臂 | 通过(一轮) | 通过(最终) | 首轮语法错 | 平均修复轮(过例) | token(p+c) | infra 剔除 | +|---|---|---|---|---|---|---| +| query | 0/3 | 0/3 | 2/3 | – | 69,771(42,478+27,293) | 3/6 | +| docs | 3/6 | **4/6** | 2/6 | 0.50 | 57,276(33,346+23,930) | 0/6 | + +- **docs 臂**:业务题 3/3 全部一轮通过(各 ~3k token);`qb_gcd` 修复 2 轮过;`qb_max_sublist_sum`、`qb_get_factors` 暴露真语法滑倒(列表字面量被当调用 `unknown function [-2,`;参数名漂移 `missing argument for parameter value`)。 +- **query 臂**:查询通道**被积极使用**(5/6 例用满 3 次,多词查询如 `条件分支 写法` 也能正确命中卡片——已单独验证查询匹配无缺陷);但 3 例被端点空体吃掉,其余 3 例败于真语法错(Python 式元组 `(a, b)` ⇒ `trailing input in expression`;Python 式调用 `gcd(48, 18)` ⇒ `unknown function gcd(48`)与 1 例查询后未交程序。 + +### mimo-v2.6-pro(重跑中) + +首跑 12/12 全部"非 JSON / 空体"(与 deepseek 并行时段;同参数小冒烟正常)。三向探针(小提示词×12000/4000、大提示词×12000)证实**网关随机空体**、与 `max_tokens`/提示词体量无稳定关系。已将重试 8→12 次、退避 10→15 秒,并**单独**重跑(不与其它模型抢并发)。结果落地后补入本节。 + +### 判据对照(截至 deepseek-flash) + +| 判据(协议 §2.4 原文口径) | 目标 | 实测(deepseek-flash,非 infra 口径) | 判定 | +|---|---|---|---| +| 最终通过率(≤3 轮)Q 不劣于 D(允许 −0 例) | ≥ D | 0/3 vs 4/6 | ❌ | +| 首轮语法错误率 Q ≤ D | ≤ | 2/3 vs 2/6 | ❌ | +| 平均修复轮次 Q ≤ D | ≤ | query 臂无通过例,不可比 | ⚠️ | +| token 用量 Q ≤ 70% of D | ≤ 40,093 | 69,771(D 的 121.8%) | ❌ | +| (观测项)首轮契约诊断率 Q ≤ D | – | 1/3 vs 0/6 | ➖ 观测 | + +**诚实结论:在 deepseek-flash 上,"查询式"没有跑赢"全背诵"**——三项可判量化判据未达,按协议 §3.7 判定:**四判据未全成立 ⇒「AI 不必学语法」本轮未获实证,继续改协议**(不是证伪——infra 吞掉 query 臂一半样本,非 infra n=3)。要点: + +1. **统计力被端点削弱**:query 臂 6 例中 3 例被空体吃掉(协议无从执行),非 infra 样本 n=3;mimo-v2.6-pro 整组不可用。判据是"有方向的强声明",当前证据**不足以支持也未证伪**其普适性,只能定格为"deepseek-flash × 本任务集 × 本协议版本"下的一次未达标观测。 +2. **失败模式是真发现**:查询臂的败例是**跨语言习惯泄漏**(元组表达式、Python 调用形)——查询卡片能回答"条件分支怎么写",但模型不查询"这里能不能用元组"。说明"AI 不必学语法"的瓶颈不在**查询机制**,而在**模型的自查纪律**(不知道自己不知道)。 +3. **token 判据方向存疑**:查询式省的是**系统提示词常驻**(背诵包),花的是**多轮往返**。6 例短程序任务里往返开销 > 常驻节省;该判据更适用于**长会话多文件**场景(一次背诵包 × N 轮 vs 每轮均摊查询),本轮任务形态低估了查询式的收益面。 +4. **docs 臂的 4/6 说明任务集有区分度**(不是全过/全不过的退化测量)。 + +## 4. 测量端基础设施记录(方法学附注) + +- **LLM 端点不稳定**是本轮最大的干扰源:随机空体、reasoning 模型 `finish=length` 截断(思考吃满额度、正文为空)。对策:空体重试 5→12 次 + 退避 5→15 秒、截断自适应(`max_tokens` 加倍重试,封顶 32k)、infra 例从判据比率中剔除并单列。 +- **harness 缺陷两处**(已修,未污染最终数据):查询额度用满后的续篇被当最终回复(⇒ 假"无程序");程序提取失败不进修复回路(⇒ 少给模型一次标准修复机会)。修复后的协议对两臂完全一致。 +- **模型口径变化留痕**:原定 `cflmy`/`mimo-v2.6-flash` 组合按用户指示弃用,改 `mimo-v2.6-pro`/`deepseek-flash`;修复实验 (a) 的双模型数据仍是原组合(金 20 协议已完成,不重跑)。 + +## 5. 材料与复现 + +```bash +# (a) 锚点消融(需要 API key) +cargo test --test repair_experiment -- --ignored --nocapture # anchor/plain 双臂×20例 +# (b) 盲测(每模型一次;建议单独跑避免并发) +OPENAI_MODEL=deepseek-flash MARQDO_EXP_DATE=2026-09-23 cargo test --test blind_experiment -- --ignored --nocapture +# (c)(d) 确定性 +cargo test --test contract_ablation --test drift_drill +# (e) 核心守卫(变异注入→必红→还原必绿,按 perf-validation.md §5 手法) +cargo test --test core_surface +``` + +- 任务书 / 背诵包(冻结,勿改):`tests/blind/` +- 原始报告:[blind-experiment-2026-09-23-deepseek-flash.md](blind-experiment-2026-09-23-deepseek-flash.md) · [blind-experiment-2026-09-23-mimo-v2.6-pro.md](blind-experiment-2026-09-23-mimo-v2.6-pro.md)(首跑全 infra)· [repair-experiment-2026-09-22.md](repair-experiment-2026-09-22.md) · [repair-experiment-2026-09-22-mimo-v2.6-flash.md](repair-experiment-2026-09-22-mimo-v2.6-flash.md) +- 判据协议:[perf-validation.md](perf-validation.md)(版本化于本仓库,实验前冻结) diff --git a/doc/roadmap/perf-validation.md b/doc/roadmap/perf-validation.md new file mode 100644 index 0000000..9cb0315 --- /dev/null +++ b/doc/roadmap/perf-validation.md @@ -0,0 +1,125 @@ +# P4 性能验证设计(实验协议与判据) + +| | | +|---|---| +| 状态 | **Accepted · P4 执行依据** | +| 日期 | 2026-09-23 | +| 授权 | 用户授权**自行设计**本性能验证设计(P4 不再等待外部文档导入;`doc/next/002.md` 与性能验证无关) | +| 上位判据 | [three-problems.md](three-problems.md) §5.1 判据矩阵 + §5.2 实验 (a)–(e);「判据矩阵全绿 + 实验数字可复现之前,三大问题一律视为未解决」 | +| 工程任务 | [three-problems-plan.md](three-problems-plan.md) Phase 1–3(已完成);本文只负责**验证它们** | + +> **本文定位**:把 three-problems.md §5.2 的五个实验操作化——每个实验给出**材料、协议、指标、判据**,全部机器可执行、数字可复现。实验产物 = 报告 [perf-validation-report-2026-09-23.md](perf-validation-report-2026-09-23.md)。**只认行为与数字,不认宣言。** + +## 0. 总览 + +| 实验 | 验证对象 | 判据(全过 = 该问题的实证成立) | 执行方式 | 状态 | +|------|----------|-------------------------------|----------|------| +| (a) 锚点修复消融 | 问题三 · 可靠反馈 | 一轮修复率 ≥ 80%(anchor 臂),护栏 0 越界 | 模型在环 `tests/repair_experiment.rs` | ✅ 已完成(三轮双模型) | +| (b) 盲测 | 问题三 · 不必学语法 | 查询组错误率 ≤ 全文档组;token 显著更少;修复轮次不升 | 模型在环 `tests/blind_experiment.rs` | 见报告 | +| (c) 契约消融 | 问题二 · 语义校验 | 拦截率 = 100%;误报率 = 0%;无契约路径零回归 | 确定性 `tests/contract_ablation.rs` | 见报告 | +| (d) 防漂移演练 | 问题二 · 契约可信 | 故意写错契约必报率 = 100% | 确定性 `tests/drift_drill.rs` | 见报告 | +| (e) 核心守卫演练 | 问题一 · 核心要小 | 三种变异注入各必红 → 还原必绿 | 变异脚本(见 §4) | 见报告 | + +判定口径([three-problems.md](three-problems.md) §5.1):**任何一项判据不成立,对应问题即「未解决」**——不许用文档宣言充数。 + +--- + +## 1. 实验 (a):锚点修复消融(问题三 · 可靠反馈) + +**假设**:诊断带 `doc_anchor`/`doc_quote`/`suggestion`(锚点诊断)比裸诊断显著提高一轮修复率。 + +- **对照**:`anchor` 臂(全量诊断字段)vs `plain` 臂(剥掉 doc_anchor/doc_quote/suggestion)。 +- **材料**:golden 20 例(10 骨架 × 2 变体:arg/ret/field/key/typo/drift/dup),易锚定错误。 +- **协议**:`validate` → `repair_targets` → 模型行编辑 → `repair_apply`(越界必拒/abstain)→ 复验;≤2 轮。 +- **指标**:一轮修复率、最终修复率、平均尝试、越界拒、弃权。 +- **判据**:anchor 臂一轮修复率 ≥ 80%;护栏 0 次越界应用(越界必拒由 `tests/repair_loop.rs` 硬断言兜底)。 +- **执行**:`OPENAI_MODEL=… cargo test --test repair_experiment -- --ignored --nocapture`。 +- **结果**:三轮双模型全过(cflmy anchor 100% / mimo 90%→100%,plain 85%–100%,护栏 0 越界)—— + 详见 [repair-experiment-2026-09-22.md](repair-experiment-2026-09-22.md) 与 + [repair-experiment-2026-09-22-mimo-v2.6-flash.md](repair-experiment-2026-09-22-mimo-v2.6-flash.md)。**✅ PASS**。 +- **诚实注记**:样本为易锚定错误(两臂近天花板),锚点增量的区分性证据留待难样本扩展;不影响本判据达标。 + +## 2. 实验 (b):盲测——查询式 vs 全文档背诵(问题三 · 超级核心) + +**假设**:「零语法文档 + MLSP 查询」组(Q)成绩**不劣于**「全文档背诵」组(D),且 prompt token 显著更少、修复轮次不升([three-problems.md](three-problems.md) §3.7 最终判据)。 + +### 2.1 对照(唯一变量 = 语法知识的获取方式) + +| 臂 | 系统提示词内容 | 语法知识来源 | +|----|----------------|--------------| +| **Q 查询组** | 硬规则(12 条)+ 契约表三形状 + MLSP 查询通道说明 | 按需 `QUERY: <关键字>`(≤3 次,harness 代答 `mlsp syntax` 卡片) | +| **D 全文档组** | 硬规则(12 条)+ 契约表三形状 + **完整 markup 参考**(`tests/blind/docs-bundle.md`:v0.3 全语法表 + 中文内建面) | 上下文预载(背诵) | + +两臂共同点:硬规则与契约表形状**同文**(受控变量,不测契约知识差异);修复回路相同(`mlsp validate` 诊断回喂,≤2 轮);模型 / 温度 / 任务 / 提示词模板相同。 + +### 2.2 材料:任务集(6 例,业务 3 + 算法 3) + +| id | 类型 | 任务 | 功能 oracle(stdout 精确匹配) | +|----|------|------|-------------------------------| +| `claims_reserve_settle` | 业务 | 保险准备金(免赔/共保/分项限额/追偿/地板) | `28000` | +| `contract_milestone_pay` | 业务 | 工程里程碑应付款(保留金/逾期罚/变更/税/地板) | `37354` | +| `vendor_po_gate` | 业务 | 采购 PO 准付闸(折扣/加急/预算帽/合规费/地板) | `814` | +| `qb_gcd` | 算法 | 最大公约数;打印 gcd(48,18) gcd(1071,462) gcd(0,5) gcd(17,5) 各一行 | `6` `21` `5` `1` | +| `qb_max_sublist_sum` | 算法 | 最大子段和;三组输入各打印一行 | `6` `6` `-1` | +| `qb_get_factors` | 算法 | 质因数分解,因数以 `*` 连接;12 / 13 / 60 各一行 | `2*2*3` `13` `2*2*3*5` | + +业务任务书复用 MarqdoThesis `formal/exp3-bizreq/data/tasks/`(权威规则文本原样进入提示词);算法任务书为 QuixBugs 改写(从「修 bug」改「实现 + 固定输出」,消除参考源码变量)。 + +### 2.3 协议(每例) + +1. 提示词 = 任务书 + 「输出完整 `.mq.md` 源码于单个 ```markdown 围栏」; +2. **查询阶段**(仅 Q 臂):模型可输出 `QUERY: <关键字>` 行,harness 以 `mlsp syntax` 卡片作答并继续;累计 ≤3 次; +3. **执行阶段**:`marqdo run` → stdout == oracle 即通过;失败则回喂 `mlsp validate` 结构化诊断 + stderr,允许 ≤2 次修复; +4. 记录每轮 token(API `usage.prompt_tokens + completion_tokens` 累计)。 + +### 2.4 指标与判据 + +| 指标 | 口径 | 判据 | +|------|------|------| +| 功能通过率(一轮 / 最终≤3 轮) | stdout 与 oracle 精确匹配 | Q 最终通过率**不劣于** D(允许 −0 例) | +| 首轮语法错误率 | 首轮 `validate`/run 出现 parse 类失败的例数占比 | Q ≤ D | +| 首轮契约诊断率 | 首轮出现 `contract.*` 诊断的例数占比 | Q ≤ D(观测项) | +| 平均修复轮次 | 通过前的修复次数(含首轮生成记 0) | Q ≤ D | +| token 用量 | 逐例累计 prompt+completion | Q **显著更少**(≤ 70% of D) | + +**判定**:四条判据全成立 ⇒ 「AI 不必学语法」实证成立;否则按 §3.7「继续改协议」,不得以改进文档充数。 +- **执行**:`OPENAI_MODEL=… cargo test --test blind_experiment -- --ignored --nocapture`(每模型一轮)。 + +## 3. 实验 (c):契约消融(问题二 · 语义校验) + +**假设**:契约只在**有契约处**拦截错误值(P1:无契约 = 全动态),且不误报。 + +- **材料**:`tests/contract_ablation.rs` 内联四边界用例(调用实参 / 返回 / 表绑定 / 字段访问)×三形态: + ① 带契约 + 错值 → **必拦**(`contract.*` 诊断);② 带契约 + 对值 → **零误报**(正常产出);③ 同程序**删契约表** + 错值 → **零契约诊断**(动态语义原样)。 +- **指标与判据**: + - 拦截率 = ①被拦 / ①总数 = **100%**; + - 误报率 = ②误报 / ②总数 = **0%**; + - 无契约零回归 = ③零 `contract.*` 诊断且输出 = 动态语义基线;且全量 `cargo test` 绿(441+ 既有测试是无契约路径的主回归面)。 +- **执行**:`cargo test --test contract_ablation`。 + +## 4. 实验 (d):防漂移演练(问题二 · 契约可信) + +**假设**:契约写错**必**被机器抓(不静默信任契约)——three-problems.md §2.8「故意写错契约的金样必红」。 + +- **材料**:`tests/drift_drill.rs`——故意写错契约的 N 例(类型 typo `nubmer`、未知对象类型、契约参数名 ≠ 升参名 ×2、返回契约明显不符、重复契约表、错位契约表)+ **负对照**(被绑定的 `字段|类型` 数据表 = web_db_migration 式,必须**不**被当契约吃掉)。 +- **指标与判据**: + - 必报率 = 漂移例被诊断(`check` 报错/警告或运行时 `contract.*`)/ 漂移例总数 = **100%**; + - 负对照误报 = **0**。 +- **执行**:`cargo test --test drift_drill`。 + +## 5. 实验 (e):核心守卫演练(问题一 · 核心要小) + +**假设**:核心表面任何**单侧**变更(代码/文档/金样不同步)→ CI 必红——three-problems.md §1.5「新增标记不更新清单时 CI 必须红」。 + +- **材料**:`tests/core_surface.rs` 守卫 + 三种变异注入(脚本化,`git checkout` 还原): + 1. `src/parse/mod.rs` `CORE_CONSTRUCTS` 增一行、不改文档 → **必红**; + 2. `doc/design/core-surface.md` 表增一行、不改代码 → **必红**; + 3. 金样文件改名(路径失效)→ **必红**。 +- **指标与判据**:3/3 变异注入后守卫测试红;还原后全绿。**必红率 = 100%**。 +- **执行**:报告内嵌演练记录(命令 + 测试输出摘录)。 + +## 6. 报告与复现 + +- 报告:[perf-validation-report-2026-09-23.md](perf-validation-report-2026-09-23.md)((a) 引用既有两份实验报告;(b)–(e) 本次产出)。 +- 复现命令全部写入报告各节;模型在环实验记录模型名与端点,判据数字允许 ±1 例波动(模型非确定性),**判据线本身不放宽**。 +- 汇总结论回填 [three-problems-plan.md](three-problems-plan.md) 落地记录;§5.1 判据矩阵逐行标注 ✅/❌。 diff --git a/doc/roadmap/three-problems-plan.md b/doc/roadmap/three-problems-plan.md index 344ff3c..658bdc5 100644 --- a/doc/roadmap/three-problems-plan.md +++ b/doc/roadmap/three-problems-plan.md @@ -5,7 +5,7 @@ | 状态 | **本期开发依据 · 执行中** | | 日期 | 2026-09-22 | | 设计 | [three-problems.md](three-problems.md)(解决方向与验证设计;判据矩阵 §5.1) | -| 范围 | **工程任务 = Phase 1–3**;验证实验(three-problems.md §5.2)**不属于开发任务**,待「性能验证设计」(`doc/next/`,用户维护)导入后对接 | +| 范围 | **工程任务 = Phase 1–3**;验证实验(three-problems.md §5.2)协议见 [perf-validation.md](perf-validation.md)(2026-09-23 用户授权自行设计并执行) | | 约定 | 每任务带机器可验证验收;**任务完成 = 验收全绿 + 全量回归绿**;只改宣言不改行为 = 未完成 | ## 0. 本期范围与依赖 @@ -128,9 +128,11 @@ T1.1 core-surface ─是─> T3.1 语言面 + T1.3 守卫 --- -## Phase 4 · 验证实验(**非开发任务**) +## Phase 4 · 验证实验(**协议 = [perf-validation.md](perf-validation.md)**) -- 对接「性能验证设计」(`doc/next/`,用户维护,待导入);three-problems.md §5.2 实验 (a)–(e) 的**材料由 Phase 1–3 的验收金样直接供给**;开发侧仅保留「实验基建适配」支持义务(复用 MarqdoThesis `formal/exp1–3` runner/oracle)。 +- 2026-09-23 用户授权**自行设计**性能验证设计并执行验证;`doc/next/002.md` 与性能验证无关(此前「待导入」表述已纠正)。 +- five 实验 (a)–(e) 的**材料由 Phase 1–3 的验收金样直接供给**;协议 / 指标 / 判据见 [perf-validation.md](perf-validation.md) §1–§5; + 实验产物 = [perf-validation-report-2026-09-23.md](perf-validation-report-2026-09-23.md)。 --- @@ -201,3 +203,23 @@ T1.1 core-surface ─是─> T3.1 语言面 + T1.3 守卫 - **T3.3(AI Skill 换骨:背语法 → 查 MLSP)**(2026-09-22 完成)——`marqdo` / `marqdo-dev` 两件套改为 查询式工作流:写码前 `mlsp syntax/locate`、提交前 `mlsp validate` + `marqdo check`; 渐进式契约三种表格形状入语法面;错误修复照 `doc_anchor` 局部改(越界必弃权)。 + +## Phase 4 · 验证执行记录(2026-09-23,协议 [perf-validation.md](perf-validation.md)) + +- **(a) 锚点修复消融** ✅ PASS——判据「anchor 一轮 ≥80% + 护栏 0 越界」:cflmy anchor 20/20=100%(plain 85%)、 + mimo-v2.6-flash anchor 20/20=100%(plain 90%),越界拒/越界应用 0/0。易锚定样本近天花板, + 增量区分性留难样本扩展(协议 §1 诚实注记)。 +- **(b) 盲测(查询式 vs 全文档背诵)** ❌ 四判据未全立 ⇒ 按 three-problems.md §3.7 **继续改协议**—— + deepseek-flash:docs 4/6 vs query 0/3(端点 infra 剔除 3/6);首轮语法错 2/3 vs 2/6;token 69,771 vs 57,276。 + mimo-v2.6-pro 首跑 12/12 全端点空体,单独重跑(结果回填 [perf-validation-report-2026-09-23.md](perf-validation-report-2026-09-23.md) §3)。 + **真发现**:查询机制本身无缺陷(多词查询亦正确命中卡片),败例是**跨语言习惯泄漏**(元组表达式/Python 调用形) + ——模型"不知道自己不知道"而不去查。协议改进主攻方向:**自查触发机制**(validate 前置自检、 + 陌生构造强制查询),而非继续改进卡片。 +- **(c) 契约消融** ✅ PASS——拦截率 4/4=100%、误报率 0/4=0%、无契约零回归 4/4(四边界:调用实参/返回/表绑定/键访问)。 +- **(d) 防漂移演练** ✅ PASS——必报率 9/9=100%(9 类故意写错全数诊断)、负对照误报 0/2。 +- **(e) 核心守卫演练** ✅ PASS——3/3 变异注入必红(清单私增/文档私增/金样删除)、还原必绿。 +- **判据矩阵回填**:three-problems.md §5.1 逐行标注——问题 1 ✅、问题 2 ✅、**问题 3 ❌(未解决)**。 +- **测量端记录**:LLM 网关随机空体为最大干扰(重试 5→12 次、退避 5→15 秒、截断自适应 max_tokens); + harness 修复两处协议性 bug(查询额度用满误判、提取失败不进修复回路)后采样; + 模型口径按用户指示由 `cflmy`/`mimo-v2.6-flash` 改 `mimo-v2.6-pro`/`deepseek-flash`(实验 (a) 数据为原组合,不重跑)。 +- **全量干净回归**(无 API key 基线)零失败。 diff --git a/doc/roadmap/three-problems.md b/doc/roadmap/three-problems.md index 268c008..f0afb67 100644 --- a/doc/roadmap/three-problems.md +++ b/doc/roadmap/three-problems.md @@ -9,7 +9,7 @@ | 来源 | [001.md](../next/001.md) 评审讨论提炼的三大问题;用户决议:**问题二走「渐进式契约 / 标注类型」**(拒绝照搬静态类型,也拒绝放弃语义校验);**问题三(AI 可靠反馈 + AI 不必学语法)是下一步的超级核心** | | 相关 | [markdown-mapping-v0.3.md](../design/markdown-mapping-v0.3.md)(语法宪法)· [tables-maps-footnotes.md](tables-maps-footnotes.md)(表格几何)· [catalog-cli.md](../design/catalog-cli.md) · [ai-skill.md](../design/ai-skill.md) · [objects.md](../design/objects.md) · [interpreter.md](interpreter.md) | -> **本文定位:三大问题的解决方向与验证设计。** 给三大问题定义「什么算被解决」(机器可验证判据,见 §5.1)与验证实验(修复率 / 盲测 / 消融 / 防漂移演练,见 §5.2),把「真正解决」与「遮盖过去」区分开。文中的解决步骤(各节 S 表)是**设计方向**;本期开发任务、排期与验收以 [three-problems-plan.md](three-problems-plan.md) 为准。**验证实验(§5.2)不属于开发任务**——待「性能验证设计」文档导入后另行对接。 +> **本文定位:三大问题的解决方向与验证设计。** 给三大问题定义「什么算被解决」(机器可验证判据,见 §5.1)与验证实验(修复率 / 盲测 / 消融 / 防漂移演练,见 §5.2),把「真正解决」与「遮盖过去」区分开。文中的解决步骤(各节 S 表)是**设计方向**;本期开发任务、排期与验收以 [three-problems-plan.md](three-problems-plan.md) 为准。**验证实验(§5.2)协议见 [perf-validation.md](perf-validation.md)**(2026-09-23 用户授权自行设计并执行)。 > > **一句话:语言核心收口是地基;渐进式契约是校验层,schema 直接长在表格与说明段落里;AI 语言服务消费这两者形成可靠闭环。** 三个问题必须一起解——契约是 AI 接口的数据源,核心收口是契约语法不膨胀的前提。 @@ -359,11 +359,15 @@ validate(p) → diagnose → patch(p, diag) → validate(p') → … (预算 N ### 5.1 判据矩阵:什么算「已解决」 -| 问题 | 解决的定义(机器可验证) | 遮盖式收场(一句话就能写完的,禁止) | 验证手段 | -|------|--------------------------|--------------------------------------|----------| -| 1 核心要小 | 新标记不更新 core-surface → **CI 红** | 「我们重视语言核心」 | CI 守卫演练:故意加标记不更新清单,必须红 | -| 2 语义校验 | 四边界校验器上线;契约写错**必**被机器抓;无契约路径零回归 | 「静态类型是非目标」/照搬 TS 类型/另写 JSON Schema | 契约金样 + 防漂移金样 + 全量回归 | -| 3 AI 反馈 / 语法 | 盲测组错误率 ≤ 全文档组且 token 显著更少;一轮修复率可复现 | 「再写更好的文档」 | §5.2 实验 (a)(b)(d) | +| 问题 | 解决的定义(机器可验证) | 遮盖式收场(一句话就能写完的,禁止) | 验证手段 | 判定(2026-09-23) | +|------|--------------------------|--------------------------------------|----------|--------------------| +| 1 核心要小 | 新标记不更新 core-surface → **CI 红** | 「我们重视语言核心」 | CI 守卫演练:故意加标记不更新清单,必须红 | ✅ (e) 3/3 必红→还原必绿 | +| 2 语义校验 | 四边界校验器上线;契约写错**必**被机器抓;无契约路径零回归 | 「静态类型是非目标」/照搬 TS 类型/另写 JSON Schema | 契约金样 + 防漂移金样 + 全量回归 | ✅ (c) 拦截 100%/误报 0%/零回归;(d) 必报 9/9 | +| 3 AI 反馈 / 语法 | 盲测组错误率 ≤ 全文档组且 token 显著更少;一轮修复率可复现 | 「再写更好的文档」 | §5.2 实验 (a)(b)(d) | ❌ (a) 过(双模型 100%);**(b) 四判据未全立** ⇒ 按 §3.7 继续改协议 | + +> 2026-09-23 实测数字与判据对照:[perf-validation-report-2026-09-23.md](perf-validation-report-2026-09-23.md)。 +> 按本矩阵口径:**问题 1、2 实证成立;问题 3 未解决**(查询式盲测未跑赢全背诵——详见报告 §3 的四条要点, +> 其中「模型不查自己不知道的语法」是协议改进的主攻方向)。 ### 5.2 实验设计(性能 / 可靠性验证) diff --git a/src/mlsp.rs b/src/mlsp.rs index e734f97..1929540 100644 --- a/src/mlsp.rs +++ b/src/mlsp.rs @@ -93,17 +93,53 @@ const ALIASES: &[(&str, &[&str])] = &[ ("soft-emphasis", &["强调", "emphasis", "软强调"]), ]; +/// core-surface.md 全文(与 `tests/core_surface.rs` 守卫同源)——卡片机械携带 +/// 语义/戒律/样例**原文**,AI 一次查询即可自持,不必回读文档(three-problems.md §3.2「单构造戒律」)。 +const SURFACE_MD: &str = include_str!("../doc/design/core-surface.md"); + +/// 机械提取 core-surface.md 清单行:`| \`id\` | 外形 | 语义 | 戒律 | 样例 |` → +///(语义, 戒律, 样例, 行原文);只读不改,卡片内容与文档永不漂移。 +fn surface_row(id: &str) -> Option<(String, String, String, String)> { + for line in SURFACE_MD.lines() { + let t = line.trim(); + if !t.starts_with('|') { + continue; + } + let cells: Vec<&str> = t.trim_matches('|').split('|').map(str::trim).collect(); + if cells.len() != 5 { + continue; + } + let rid = cells[0].trim_matches('`'); + if rid == id && !rid.is_empty() && !rid.contains(' ') && !rid.starts_with('-') { + return Some(( + cells[2].to_string(), + cells[3].to_string(), + cells[4].to_string(), + t.to_string(), + )); + } + } + None +} + fn card(id: &str) -> Value { let form = CORE_CONSTRUCTS .iter() .find(|(cid, _)| *cid == id) .map(|(_, f)| *f) .unwrap_or("?"); - json!({ + let mut v = json!({ "id": id, "form": form, "manual": "doc/design/core-surface.md", - }) + }); + if let Some((semantics, rule, sample, quote)) = surface_row(id) { + v["semantics"] = semantics.into(); + v["rule"] = rule.into(); + v["sample"] = sample.into(); + v["doc_quote"] = quote.into(); + } + v } fn match_constructs(query: &str) -> Vec { diff --git a/tests/blind/docs-bundle.md b/tests/blind/docs-bundle.md new file mode 100644 index 0000000..1cc9706 --- /dev/null +++ b/tests/blind/docs-bundle.md @@ -0,0 +1,117 @@ + + +## Markup → meaning (v0.3) + +| Marker | Meaning | +|--------|---------| +| `#` | **Object / type** (constructor body). `# main` = entry object. `# Child = > Parent` = inherit (**no** implicit parent constructor; call `` `self` = > Parent … `` explicitly when needed). | +| `##` … `######` | **Function / method** (nesting by heading depth). | +| `` + `name` `` under heading | Parameter (optional `` `name`=default ``) | +| `1.` `2.` … in body | Branch arm (condition or `N. *` else). **Same-indent restart at `1.` = new branch statement** (not more arms of the previous list). | +| `- …` inside body | Loop (`while` or `` [item](coll) `` / `` [`item`](`coll`) ``) | +| Line `N. *` | Else arm | +| `> fn args` | Call (named `k=v` or positional) | +| `修饰 [fn] args` | Bracket-marked call; leading words → `名=True` | +| `` > `obj`.method args `` | Method call (`obj` must be a map with `_type`) | +| Frontmatter `import bind:path.mq.md` / `导入` | Import file (bind library name) | +| Frontmatter `import bind:lib.member` / `导入` | Short name for a library member (same keyword; no separate `use`) | +| `> lib.member …` / `> lib.Type.member …` | Call via bare dotted path (instance methods need `` `var`.m ``) | +| `**…**` | **Code** (assign / call) — closing `**` touches last token; bare ids are variables; quote text literals | +| `*…*` | **Return value** — closing `*` touches last token; bare ids are variables | +| `****` / whole-line `**` / `*None*` | Return `None` and end function body | +| Lone `---` / `***` | Markdown thematic break (skip; not function end) | +| GFM table after empty RHS bind | Collection; get with `[key](coll)` (preferred) or legacy `` `m`[^key] `` | +| `- [item](coll)` | Foreach (unchanged) | +| `` ```lang `` | Foreign code block (via `lib/foreign`) | +| `` `"text"` `` | Quoted string (`\n` `\t` `\\` `\"`; `` `var` `` inside); bare tokens unescaped | +| Unmarked prose | Comment | + +Entry: load file (often `index.mq.md`) → collect defs → run `# main`. + +## Minimal program + +```markdown +# main + +> print text=Hello World! +``` + +Chinese builtins (same functions, no import): + +```markdown +# main + +> 打印 内容=你好 +``` + +## Functions, calls, end-body + +```markdown +# main + +> greet who=Marqdo + +## greet + + `who` + +> print text=Hello, `who`! + +*None* +``` + +- Call: `> name key=value` or `> name value`. +- Nested helpers use deeper `#` (`##`, `###`, …). +- After a helper with only side effects, end with `*None*` / whole-line `**` / `****` when later lines must stay in the outer function. Lone `---` is only a thematic break (skipped). +- In bold assigns, prefer bare calls: `**摘要 = 结账摘要 …**` (omit `>`). + +## Statements, returns, branches + +```markdown +**x = 1** +**y = x + 2** + +## add_one + + `n` + +*n + 1* +``` + +```markdown +**n = 0** + +1. `n` > 0 + > print text=positive +2. `n` < 0 + > print text=negative +3. * + > print text=zero +``` + +## Frontmatter imports + stdlib + +Imports use `import bind:target` (`导入` equivalent): file (`.mq.md`) or short name (`lib.member`). Members are **not** flattened into the caller. Call with a bare dotted path: + +```markdown +--- +title: example +import text:lib/text.mq.md +import clock:lib/time.mq.md +--- + +# main + +**xs = > text.str_split s="a,b,c" sep=","** +> print text=`xs` +**t = > clock.now_unix** +``` + +- Import **English** or **Chinese** library file; call that file's API names via `lib.member` (do not mix languages). +- Instance methods stay `` > `obj`.method `` (backticks on the receiver only). +- `lib/…` resolves via `MARQDO_LIB`, cwd `lib/`, or `lib/` next to the `marqdo` binary. +- Prefer `table.put` / `表.改` for list/map element updates; keep `json` for parse/stringify/quote. +- Builtins (no import): `print`/`打印`, `input`/`输入`, `len`/`长度`, `str`/`文本`, `int`/`整数`; literals `True`/`真`, `False`/`假`, `None`/`空`; logic `and`/`且`, `or`/`或`, `not`/`非`. diff --git a/tests/blind/tasks/claims_reserve_settle.md b/tests/blind/tasks/claims_reserve_settle.md new file mode 100644 index 0000000..7640b2e --- /dev/null +++ b/tests/blind/tasks/claims_reserve_settle.md @@ -0,0 +1,36 @@ +# Task: claims_reserve_settle (insurance claims reserve) + +Implement an **insurance claims reserve settlement** desk. +This is a **business-policy** pipeline (deductible, coinsurance, sublimit, recovery, floor), **not** an algorithms puzzle. +Use **integer arithmetic only**. Hardcode the demo inputs below and **print one integer**: the final reserve. + +## Business requirements (authoritative) + +1. **After deductible:** `after_deduct = claim - deductible`. If `after_deduct < 0`, set `after_deduct = 0`. +2. **Coinsurance share (insurer):** `coinsured = after_deduct * coinsure_pct / 100` (demo coinsure_pct = 80). Apply coinsurance **before** recovery. +3. **Sublimit cap:** `capped = coinsured` if `coinsured <= sublimit`, else `capped = sublimit` (never enlarge beyond coinsured). +4. **Recovery offset:** `reserved = capped - recovery`. If `reserved < 0`, set `reserved = 0`. +5. **Reserve floor:** if `reserved < reserve_floor`, set `reserved = reserve_floor`. + +## Demo inputs (hardcode) + +- `claim = 50000` +- `deductible = 5000` +- `coinsure_pct = 80` +- `sublimit = 30000` +- `recovery = 2000` +- `reserve_floor = 1000` + +## Requirements + +- Provide named helpers (or clear stages) for deductible, coinsurance, sublimit, recovery, and floor — not one opaque expression. +- Print only the final integer (no labels). +- Align to the **business requirements above**; do not invent alternate order or comparison directions. + +## Expected output (self-check) + +Exactly one line: `28000` + +## Deliverable + +Write the program as a Marqdo `.mq.md` file. Return the complete source in a single ```markdown fence — no prose outside the fence. diff --git a/tests/blind/tasks/contract_milestone_pay.md b/tests/blind/tasks/contract_milestone_pay.md new file mode 100644 index 0000000..d8a901c --- /dev/null +++ b/tests/blind/tasks/contract_milestone_pay.md @@ -0,0 +1,42 @@ +# Task: contract_milestone_pay (construction milestone payable) + +Implement a **contract milestone payment** desk for an EPC / construction settlement. +This is a **business-policy** pipeline (retention, late penalty, change order, tax), **not** an algorithms puzzle. +Use **integer arithmetic only**. Hardcode the demo inputs below and **print one integer**: the final payable. + +## Business requirements (authoritative) + +1. **Earned value:** `earned = contract_value * progress_pct / 100`. +2. **Retention withhold:** `retention = earned * retain_pct / 100` (demo uses retain_pct = 5). +3. **Net after retention:** `net = earned - retention`. +4. **Late penalty:** if `days_late > grace_days` (grace_days = 7), set `penalty = net * late_rate / 100` (late_rate = 2); otherwise `penalty = 0`. Penalty is always computed from **`net`**, never from `earned`. +5. **After penalty:** `net2 = net - penalty`. +6. **Change order:** `taxed_base = net2 + change_order`. If `taxed_base < 0`, set `taxed_base = 0`. +7. **Tax:** `tax = taxed_base * tax_rate / 100` (tax_rate = 6). +8. **Payable:** `payable = taxed_base + tax`. If `payable < min_pay` (min_pay = 500), set `payable = min_pay`. + +## Demo inputs (hardcode) + +- `contract_value = 100000` +- `progress_pct = 40` +- `retain_pct = 5` +- `days_late = 10` +- `grace_days = 7` +- `late_rate = 2` +- `change_order = -2000` +- `tax_rate = 6` +- `min_pay = 500` + +## Requirements + +- Provide named helpers (or clear stages) for earned, retention, penalty, change+tax, and floor — not one opaque expression. +- Print only the final integer (no labels). +- Align to the **business requirements above**; do not invent alternate thresholds or penalty bases. + +## Expected output (self-check) + +Exactly one line: `37354` + +## Deliverable + +Write the program as a Marqdo `.mq.md` file. Return the complete source in a single ```markdown fence — no prose outside the fence. diff --git a/tests/blind/tasks/qb_gcd.md b/tests/blind/tasks/qb_gcd.md new file mode 100644 index 0000000..e1acacf --- /dev/null +++ b/tests/blind/tasks/qb_gcd.md @@ -0,0 +1,30 @@ +# Task: qb_gcd (easy) — Greatest Common Divisor + +Implement **Greatest Common Divisor** as a function named `gcd` in a Marqdo `.mq.md` program (Euclidean algorithm). + +## Requirements + +1. Function name `gcd`, taking two integer parameters and returning their greatest common divisor (non-negative; `gcd(0, 5)` is `5`). +2. In `# main`, hardcode the demo calls below and print each result on its own line — exactly four lines, no labels. + +## Demo calls (hardcode) + +- `gcd(48, 18)` +- `gcd(1071, 462)` +- `gcd(0, 5)` +- `gcd(17, 5)` + +## Expected output (self-check) + +Four lines: + +``` +6 +21 +5 +1 +``` + +## Deliverable + +Write the program as a Marqdo `.mq.md` file. Return the complete source in a single ```markdown fence — no prose outside the fence. diff --git a/tests/blind/tasks/qb_get_factors.md b/tests/blind/tasks/qb_get_factors.md new file mode 100644 index 0000000..299dc44 --- /dev/null +++ b/tests/blind/tasks/qb_get_factors.md @@ -0,0 +1,28 @@ +# Task: qb_get_factors (hard) — Prime Factorization + +Implement **prime factorization** as a function named `get_factors` in a Marqdo `.mq.md` program. The function takes an integer `n ≥ 2` and returns its prime factors in ascending order. + +## Requirements + +1. Function name `get_factors`. +2. In `# main`, hardcode the demo inputs below and print each result on its own line — factors joined by `*` with no spaces, exactly three lines, no labels. + +## Demo inputs (hardcode) + +- `12` +- `13` +- `60` + +## Expected output (self-check) + +Three lines: + +``` +2*2*3 +13 +2*2*3*5 +``` + +## Deliverable + +Write the program as a Marqdo `.mq.md` file. Return the complete source in a single ```markdown fence — no prose outside the fence. diff --git a/tests/blind/tasks/qb_max_sublist_sum.md b/tests/blind/tasks/qb_max_sublist_sum.md new file mode 100644 index 0000000..231df3c --- /dev/null +++ b/tests/blind/tasks/qb_max_sublist_sum.md @@ -0,0 +1,28 @@ +# Task: qb_max_sublist_sum (hard) — Maximum Sublist Sum + +Implement the **maximum contiguous sublist sum** as a function named `max_sublist_sum` in a Marqdo `.mq.md` program. The function takes a list of integers and returns the maximum sum of any contiguous sublist (at least one element). + +## Requirements + +1. Function name `max_sublist_sum`. +2. In `# main`, hardcode the demo inputs below and print each result on its own line — exactly three lines, no labels. + +## Demo inputs (hardcode) + +- `[-2, 1, -3, 4, -1, 2, 1, -5, 4]` +- `[1, 2, 3]` +- `[-3, -1, -2]` + +## Expected output (self-check) + +Three lines: + +``` +6 +6 +-1 +``` + +## Deliverable + +Write the program as a Marqdo `.mq.md` file. Return the complete source in a single ```markdown fence — no prose outside the fence. diff --git a/tests/blind/tasks/vendor_po_gate.md b/tests/blind/tasks/vendor_po_gate.md new file mode 100644 index 0000000..3db0001 --- /dev/null +++ b/tests/blind/tasks/vendor_po_gate.md @@ -0,0 +1,37 @@ +# Task: vendor_po_gate (complex procurement business policy) + +Implement a **vendor purchase-order payable gate** for an enterprise procurement desk. +This is a **business-policy** task (multi-rule approval economics), **not** an algorithms puzzle. +Use **integer arithmetic only**. Hardcode the demo inputs below and **print one integer**: the final payable. + +## Business requirements (authoritative) + +1. **Base line:** `base = qty * unit_cost`. +2. **Preferred-vendor discount:** if `vendor_tier >= 2` (tier-2+ preferred suppliers), set `amount = base * 97 / 100`; otherwise `amount = base`. +3. **Rush surcharge:** if `urgency == 1`, set `amount = amount + amount * 5 / 100`; otherwise keep `amount`. +4. **Budget clamp:** if `amount > budget_cap`, set `amount = budget_cap`. +5. **Compliance fee:** if `risk_flag == 1`, `fee = 80`; else `fee = 0`. +6. **Payable floor:** `payable = amount + fee`; if `payable < 200` then `payable = 200`. + +## Demo inputs (hardcode) + +- `qty = 20` +- `unit_cost = 40` +- `vendor_tier = 2` +- `urgency = 1` +- `budget_cap = 900` +- `risk_flag = 0` + +## Requirements + +- Provide named helpers (or clear stages) for discount, rush, budget clamp, fee, and assemble — not one opaque expression. +- Print only the final integer (no labels). +- Align the program to the **business requirements above**; do not invent alternate thresholds. + +## Expected output (self-check) + +Exactly one line: `814` + +## Deliverable + +Write the program as a Marqdo `.mq.md` file. Return the complete source in a single ```markdown fence — no prose outside the fence. diff --git a/tests/blind_experiment.rs b/tests/blind_experiment.rs new file mode 100644 index 0000000..be4d672 --- /dev/null +++ b/tests/blind_experiment.rs @@ -0,0 +1,585 @@ +//! P4 实验 (b) 盲测——**查询式(Q)vs 全文档背诵(D)** +//! ([perf-validation.md](../../doc/roadmap/perf-validation.md) §2;three-problems.md §3.7 最终判据)。 +//! +//! 唯一变量 = 语法知识获取方式:Q 臂只给硬规则 + 契约表形状 + MLSP 查询通道(≤3 次); +//! D 臂给硬规则 + 契约表形状 + 完整 markup 参考(`blind/docs-bundle.md`,背诵式全语法表)。 +//! 两臂任务 / 提示词模板 / 修复回路(≤2 次)/ 模型完全相同。 +//! +//! 判据:Q 功能通过率不劣于 D;首轮语法错误率 Q ≤ D;token Q ≤ 70% of D;修复轮次不升。 +//! 执行:`OPENAI_MODEL=… cargo test --test blind_experiment -- --ignored --nocapture`。 + +use std::io::Write; + +use marqdo::mlsp::handle_line; +use serde_json::{json, Value}; + +// ---------- 材料(冻结;只读实验材料) ---------- + +const DOCS_BUNDLE: &str = include_str!("blind/docs-bundle.md"); +const T_CLAIMS: &str = include_str!("blind/tasks/claims_reserve_settle.md"); +const T_MILESTONE: &str = include_str!("blind/tasks/contract_milestone_pay.md"); +const T_VENDOR: &str = include_str!("blind/tasks/vendor_po_gate.md"); +const T_GCD: &str = include_str!("blind/tasks/qb_gcd.md"); +const T_KADANE: &str = include_str!("blind/tasks/qb_max_sublist_sum.md"); +const T_FACTORS: &str = include_str!("blind/tasks/qb_get_factors.md"); + +struct Task { + id: &'static str, + desc: &'static str, + oracle: &'static str, +} + +fn tasks() -> Vec { + vec![ + Task { id: "claims_reserve_settle", desc: T_CLAIMS, oracle: "28000" }, + Task { id: "contract_milestone_pay", desc: T_MILESTONE, oracle: "37354" }, + Task { id: "vendor_po_gate", desc: T_VENDOR, oracle: "814" }, + Task { id: "qb_gcd", desc: T_GCD, oracle: "6\n21\n5\n1" }, + Task { id: "qb_max_sublist_sum", desc: T_KADANE, oracle: "6\n6\n-1" }, + Task { id: "qb_get_factors", desc: T_FACTORS, oracle: "2*2*3\n13\n2*2*3*5" }, + ] +} + +// ---------- 提示词(受控:硬规则与契约形状两臂同文) ---------- + +const HARD_RULES: &str = "\ +## Hard rules (do not violate)\n\ +1. **File suffix** must be `.mq.md`.\n\ +2. **`**…**` = code** (assign / call). **`*…*` = return value**. Output is **not** either marker — use `> print text=…` / `**print text=\"…\"**` / `> 打印 内容=…`.\n\ +3. **Prose:** unmarked narrative may contain `` `名` `` (declare/ref), inline `**code**`, and `*return*`. Soft Markdown emphasis that is not code-shaped is ignored. Dead `` `名` `` (never read) is OK and does not become a param.\n\ +4. **Do not invent keywords** `if` / `else` / `while` / `for` / `def` / `return`. Control flow is Markdown: **`1.` `2.` … branches**, **`-` loops**, arm `N. *` = else, `#` = **object/type**, `##`+ = **function/method**. Params: prefer prose `` `名` `` / `` `名`=默认 `` (inferred); `` + `名` `` still accepted.\n\ +5. **Identifiers:** `` `名` `` in prose; inside `*…*` / `**…**`, bare ids are **variables**. **Text literals must be quoted** in bold/italic: `**print text=\"hi\"**`. Standalone `>` calls: bare words = text; vars need ticks: `` > str `n` ``.\n\ +6. **Structure lines** (`#` `>` `+` `-` `|` `1.`) need not be wrapped in bold.\n\ +7. **Paths:** In bare expressions `/` is division. In call args / defaults / table cells, unspaced `a/b` and quoted paths are text.\n\ +8. Prefer ending side-effect-only bodies with `*None*` / `*无*` / whole-line `**` / `****` when the next lines must belong to an outer function. Lone `---` / `***` are Markdown thematic breaks (skipped everywhere), not function end.\n\ +9. **`ext/**` never calls `host_*`.**\n\ +10. **Code-as-documentation:** prefer GFM tables for maps/lists; prefer named helpers over `json.set` / `json.append` chains.\n\ +11. **Table element access has two spellings** — `[键](集合)` is the recommended one (e.g. `[name](`用户`)`, `[1](`xs`)`); footnote form `` `集合`[^键] `` is legacy-compat only.\n\ +12. **Bracket-marked calls:** function name may be marked with `[函数名]`; bare words before `[` are boolean modifiers. `]` immediately followed by `(` is **index** `[key](coll)`, not a call.\n"; + +const CONTRACT_SHAPES: &str = "\ +## 渐进式契约表(可选校验元数据)\n\ +函数契约 = `##` 函数体内**首个可执行行之前**的未绑定文档表,两种列头:\n\ +\n\ +| 参数 | 类型 | 说明 |\n\ +|------|------|------|\n\ +| `n` | number | 输入值 |\n\ +\n\ +| 返回 | 类型 | 说明 |\n\ +|------|------|------|\n\ +| | number | 返回说明 |\n\ +\n\ +集合契约 = `` `名` = `` 绑定**之前**的 `| 字段 | 类型 | 可空 |` 表。\n\ +对象契约 = `# 对象` 体内首个成员之前的 `| 字段 | 类型 |` 表。\n\ +规则:**被绑定的表是数据,永不视为契约**;类型词表 = `text` / `number` / `bool` / `list` / `map` / `any` / 对象名;\n\ +契约表一经出现即为完整声明(写全参数行,否则报 param_drift 警告)。\n"; + +const QUERY_PROTOCOL: &str = "\ +## On-demand syntax queries(你的唯一语法来源)\n\ +你**没有** Marqdo 语法参考。对任何不确定的语法细节,先查询再写码:单独输出一行\n\ +`QUERY: <关键字>`(如 `QUERY: 返回`、`QUERY: 表`、`QUERY: 调用`),我会回给你对应构造卡片(语义/戒律/样例原文)。\n\ +最多 3 次查询。**不要凭 Markdown/Python 习惯猜语法。**\n"; + +fn system_prompt(arm: &str) -> String { + let intro = "你是 Marqdo 语言(`.mq.md`:Markdown 标记即语法)的程序作者。写完整可运行程序(含 `# main`)。\n\n"; + let mut s = String::from(intro); + s.push_str(HARD_RULES); + s.push('\n'); + s.push_str(CONTRACT_SHAPES); + s.push('\n'); + if arm == "docs" { + s.push_str("## Markup reference (v0.3, complete)\n\n"); + s.push_str(DOCS_BUNDLE); + } else { + s.push_str(QUERY_PROTOCOL); + } + s +} + +// ---------- LLM 接入(OpenAI 兼容;curl 免依赖;带 usage 计量) ---------- + +struct Llm { + key: String, + base: String, + model: String, +} + +struct Reply { + text: String, + ptok: u32, + ctok: u32, +} + +fn llm_cfg() -> Llm { + fn env_of(keys: &[&str]) -> Option { + keys.iter() + .find_map(|k| std::env::var(k).ok()) + .filter(|s| !s.is_empty()) + } + let mut key = env_of(&["OPENAI_API_KEY", "MARQDO_LLM_API_KEY", "USTC_LLM_API_KEY"]); + let mut base = env_of(&["OPENAI_BASE_URL", "MARQDO_LLM_BASE_URL"]); + let mut model = env_of(&["OPENAI_MODEL", "MARQDO_LLM_MODEL"]); + let env_path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join(".env"); + if let Ok(txt) = std::fs::read_to_string(&env_path) { + for line in txt.lines() { + let line = line.trim(); + if line.is_empty() || line.starts_with('#') { + continue; + } + if let Some((k, v)) = line.split_once('=') { + let v = v.trim().trim_matches('"').to_string(); + match k.trim() { + "OPENAI_API_KEY" | "MARQDO_LLM_API_KEY" => key = key.or(Some(v)), + "OPENAI_BASE_URL" | "MARQDO_LLM_BASE_URL" => base = base.or(Some(v)), + "OPENAI_MODEL" | "MARQDO_LLM_MODEL" => model = model.or(Some(v)), + _ => {} + } + } + } + } + Llm { + key: key.expect("未找到 API 密钥:请设置 OPENAI_API_KEY 或仓库根 .env"), + base: base.unwrap_or_else(|| "https://llm.cflmy.cn/v1".to_string()), + model: model.unwrap_or_else(|| "cflmy".to_string()), + } +} + +/// 多轮对话一次;空体/非 JSON/瞬时错误自动重试(容错重试),仍失败 ⇒ Err(基础设施失败)。 +fn chat(llm: &Llm, msgs: &[(String, String)]) -> Result { + let messages: Vec = msgs + .iter() + .map(|(r, c)| json!({"role": r, "content": c})) + .collect(); + let url = format!("{}/chat/completions", llm.base.trim_end_matches('/')); + let auth = format!("Authorization: Bearer {}", llm.key); + let mut last = String::new(); + let mut max_tokens = 12000u64; // reasoning 模型先思考后作答;截断时自适应加倍 + for _ in 0..12 { + let req = json!({ + "model": llm.model, + "temperature": 0, + "max_tokens": max_tokens, + "messages": messages + }); + let mut child = std::process::Command::new("curl") + .args(["-sS", "-m", "180", "--retry", "2", "--retry-all-errors", "--retry-delay", "2", &url, "-H", &auth, "-H", "Content-Type: application/json", "--data-binary", "@-"]) + .stdin(std::process::Stdio::piped()) + .stdout(std::process::Stdio::piped()) + .stderr(std::process::Stdio::piped()) + .spawn() + .expect("启动 curl"); + child + .stdin + .as_mut() + .unwrap() + .write_all(req.to_string().as_bytes()) + .unwrap(); + let out = child.wait_with_output().unwrap(); + let text = String::from_utf8_lossy(&out.stdout).to_string(); + match serde_json::from_str::(&text) { + Ok(v) if v["error"].is_object() => { + last = format!("LLM 报错: {}", v["error"]); + } + Ok(v) => { + let reply = v["choices"][0]["message"]["content"].as_str().unwrap_or(""); + if !reply.is_empty() { + return Ok(Reply { + text: reply.to_string(), + ptok: v["usage"]["prompt_tokens"].as_u64().unwrap_or(0) as u32, + ctok: v["usage"]["completion_tokens"].as_u64().unwrap_or(0) as u32, + }); + } + if v["choices"][0]["finish_reason"] == "length" && max_tokens < 32000 { + max_tokens *= 2; // reasoning 吃满额度 ⇒ 加倍后重试 + last = format!("截断(finish=length,content 空),max_tokens 加倍至 {max_tokens}"); + } else { + last = format!("响应缺 content: {}", truncate(&text, 120)); + } + } + Err(_) => { + let err = String::from_utf8_lossy(&out.stderr).to_string(); + last = format!("非 JSON / 空体: {} {}", truncate(&text, 80), truncate(&err, 80)); + } + } + std::thread::sleep(std::time::Duration::from_secs(15)); + } + Err(last) +} + +fn truncate(s: &str, n: usize) -> String { + let t: String = s.chars().take(n).collect(); + if s.chars().count() > n { + format!("{t}…") + } else { + t + } +} + +// ---------- 程序提取 / 查询 / 执行 ---------- + +/// 从回复中提取程序源:优先含 `# main` 的围栏,其次最长围栏,再次裸文含 `# main`。 +fn extract_program(reply: &str) -> Option { + let mut best: Option = None; + let mut rest = reply; + while let Some(a) = rest.find("```") { + let after = &rest[a + 3..]; + let after = after.strip_prefix("markdown").unwrap_or(after); + let after = after.strip_prefix('\n').unwrap_or(after); + if let Some(b) = after.find("```") { + let block = &after[..b]; + if block.contains("# main") { + return Some(dedent(block)); + } + if best.as_ref().map(|s: &String| s.len() < block.len()).unwrap_or(true) { + best = Some(block.to_string()); + } + rest = &after[b + 3..]; + } else { + break; + } + } + if let Some(b) = best { + return Some(dedent(&b)); + } + if reply.contains("# main") { + return Some(reply.trim().to_string()); + } + None +} + +fn dedent(block: &str) -> String { + let lines: Vec<&str> = block.lines().collect(); + let indent = lines + .iter() + .filter(|l| !l.trim().is_empty()) + .map(|l| l.len() - l.trim_start().len()) + .min() + .unwrap_or(0); + let out: String = lines + .iter() + .map(|l| l.get(indent..).unwrap_or(l)) + .collect::>() + .join("\n"); + format!("{}\n", out.trim_end()) +} + +/// QUERY 行 → 查询关键字列表。 +fn extract_queries(reply: &str) -> Vec { + reply + .lines() + .filter_map(|l| { + let t = l.trim(); + let rest = t.strip_prefix("QUERY:").or_else(|| t.strip_prefix("QUERY:"))?; + let q = rest.trim(); + if q.is_empty() { + None + } else { + Some(q.to_string()) + } + }) + .collect() +} + +fn mlp_syntax(query: &str) -> String { + handle_line(&json!({"id": 1, "method": "syntax", "params": {"query": query}}).to_string()) +} + +fn validate_codes(src: &str) -> (bool, Vec, String) { + let resp: Value = + serde_json::from_str(&handle_line(&json!({"id": 1, "method": "validate", "params": {"source": src}}).to_string())) + .expect("MLSP 响应必须是合法 JSON"); + if resp["ok"] != true { + let code = resp["error"]["code"].as_str().unwrap_or("?").to_string(); + return (false, vec![code], resp.to_string()); + } + let diags = resp["result"]["diagnostics"].as_array().cloned().unwrap_or_default(); + let codes: Vec = diags + .iter() + .filter_map(|d| d["code"].as_str().map(String::from)) + .collect(); + (true, codes, diags.iter().map(|d| d.to_string()).collect::>().join("\n")) +} + +fn run_src(task_id: &str, arm: &str, src: &str) -> (i32, String, String) { + let p = std::env::temp_dir().join(format!( + "marqdo_blind_{}_{}_{}.mq.md", + std::process::id(), + arm, + task_id + )); + std::fs::write(&p, src).unwrap(); + let out = std::process::Command::new(env!("CARGO_BIN_EXE_marqdo")) + .args(["run", p.to_str().unwrap()]) + .output() + .expect("运行 marqdo"); + let _ = std::fs::remove_file(&p); + ( + out.status.code().unwrap_or(1), + String::from_utf8_lossy(&out.stdout).to_string(), + String::from_utf8_lossy(&out.stderr).to_string(), + ) +} + +// ---------- 单例执行 ---------- + +struct Outcome { + task: &'static str, + arm: &'static str, + result: String, // pass / load-fail / run-fail / wrong-output / infra + rounds: u32, // 通过前的修复次数(首轮通过 = 0) + first_load_fail: bool, + first_contract_diag: bool, + ptok: u32, + ctok: u32, + queries: u32, + note: String, +} + +fn run_case(llm: &Llm, task: &Task, arm: &'static str) -> Outcome { + let mut msgs: Vec<(String, String)> = vec![ + ("system".into(), system_prompt(arm)), + ("user".into(), format!("{}\n\n开始写程序。", task.desc)), + ]; + let (mut ptok, mut ctok) = (0u32, 0u32); + let mut queries = 0u32; + + // 查询阶段(Q 臂协议;D 臂模型不被教导 QUERY,自然不会发) + let mut text = String::new(); + let mut infra: Option = None; + for _ in 0..6 { + match chat(llm, &msgs) { + Ok(r) => { + ptok += r.ptok; + ctok += r.ctok; + text = r.text; + } + Err(e) => { + infra = Some(e); + break; + } + } + if extract_program(&text).is_some() { + break; // 已带程序(即便附带 QUERY 行也直接用) + } + let qs = extract_queries(&text); + if qs.is_empty() { + break; // 无程序无查询 ⇒ 交给修复回路要程序 + } + let mut answer = String::new(); + for q in qs.iter().take(3usize.saturating_sub(queries as usize)) { + answer.push_str(&format!("QUERY {} → {}\n", q, mlp_syntax(q))); + queries += 1; + } + if answer.is_empty() { + answer.push_str("查询额度已用完(最多 3 次)。不要再查询,直接写完整程序。\n"); + } + msgs.push(("assistant".into(), text.clone())); + msgs.push(( + "user".into(), + format!("{answer}\n继续;完成后把完整程序放在**单个** ```markdown 围栏里。"), + )); + } + if let Some(e) = infra { + return Outcome { + task: task.id, + arm, + result: "infra".into(), + rounds: 0, + first_load_fail: false, + first_contract_diag: false, + ptok, + ctok, + queries, + note: truncate(&e, 140), + }; + } + + let mut out = Outcome { + task: task.id, + arm, + result: "infra".into(), + rounds: 0, + first_load_fail: false, + first_contract_diag: false, + ptok, + ctok, + queries, + note: String::new(), + }; + + for attempt in 0..3u32 { + let src_opt = extract_program(&text); + let (load_ok, codes, diag_txt) = match &src_opt { + Some(src) => validate_codes(src), + None => (false, vec!["harness.no_program".to_string()], String::new()), + }; + let contract_diag = codes.iter().any(|c| c.starts_with("contract.")); + if attempt == 0 { + out.first_load_fail = src_opt.is_none() || !load_ok; + out.first_contract_diag = contract_diag; + } + let (code, stdout, stderr) = match &src_opt { + Some(src) => run_src(task.id, arm, src), + None => ( + 1, + String::new(), + "回复中没有 ```markdown 围栏程序(或不含 # main)。".to_string(), + ), + }; + if code == 0 && stdout.trim_end() == task.oracle.trim() { + out.result = "pass".into(); + out.rounds = attempt; + out.note = format!("queries={queries}"); + break; + } + out.result = if src_opt.is_none() || !load_ok { + "load-fail".into() + } else if code != 0 { + "run-fail".into() + } else { + "wrong-output".into() + }; + out.note = if src_opt.is_none() { + format!("回复中无程序 | 开头: {}", truncate(&text.replace('\n', " "), 160)) + } else { + truncate(&format!("{diag_txt} | stderr={stderr}"), 300) + }; + if attempt == 2 { + break; + } + msgs.push(("assistant".into(), text.clone())); + msgs.push(( + "user".into(), + format!( + "程序未通过。\nvalidate 诊断:\n{diag_txt}\n\n运行 stderr:\n{}\n\n运行 stdout:\n{}\n\n请修复问题,把**完整**程序放在**单个** ```markdown 围栏里(围栏内是纯 Marqdo 源码,含 `# main`)。", + truncate(&stderr, 500), + truncate(&stdout, 200) + ), + )); + match chat(llm, &msgs) { + Ok(r) => { + ptok += r.ptok; + ctok += r.ctok; + text = r.text; + } + Err(e) => { + out.note = format!("infra: {}", truncate(&e, 100)); + break; + } + } + } + out.ptok = ptok; + out.ctok = ctok; + out +} + +// ---------- 实验入口 ---------- + +#[test] +#[ignore] +fn exp_b_blind_query_vs_docs() { + let llm = llm_cfg(); + let limit: usize = std::env::var("MARQDO_EXP_LIMIT") + .ok() + .and_then(|s| s.parse().ok()) + .unwrap_or(usize::MAX); + let mut outs: Vec = Vec::new(); + for arm in ["query", "docs"] { + for t in tasks().iter().take(limit) { + let o = run_case(&llm, t, arm); + eprintln!( + "[{}] {:<24} {:<12} rounds={} tok=({},{}) q={} | {}", + o.arm, o.task, o.result, o.rounds, o.ptok, o.ctok, o.queries, o.note + ); + outs.push(o); + } + } + + // 汇总(按判据口径:infra 例从比率中剔除并单列) + let mut md = String::new(); + md.push_str(&format!( + "# 盲测实验(§5.2(b) 查询式 vs 全文档背诵)—— {}\n\n| | |\n|---|---|\n| 模型 | `{}` @ `{}` |\n| 样本 | 6 任务(业务 3 + QuixBugs 改写 3),oracle = stdout 精确匹配 |\n| 协议 | 系统提示词 = 硬规则 12 条 + 契约表三形状(两臂同文);**唯一变量 = 语法来源**:`query` 臂 MLSP 查询通道(≤3 次)vs `docs` 臂完整 markup 参考(背诵) |\n| 修复 | validate 诊断 + stderr 回喂,≤2 次修复;temperature=0,max_tokens=8000 |\n\n", + chrono_date(), + llm.model, + llm.base + )); + + md.push_str("## 汇总(判据:Q 通过率不劣于 D;首轮语法错误率 Q≤D;token Q≤70%%D;轮次不升)\n\n"); + md.push_str("| 臂 | 通过(一轮) | 通过(最终≤3) | 首轮语法错误 | 首轮契约诊断 | 平均修复轮(过例) | token 合计(prompt+completion) | 弃权/基础设施 |\n"); + md.push_str("|---|---|---|---|---|---|---|---|\n"); + for arm in ["query", "docs"] { + let os: Vec<&Outcome> = outs.iter().filter(|o| o.arm == arm).collect(); + let n = os.len(); + let infra = os.iter().filter(|o| o.result == "infra").count(); + let denom = n - infra; + let pass1 = os.iter().filter(|o| o.result == "pass" && o.rounds == 0).count(); + let passf = os.iter().filter(|o| o.result == "pass").count(); + let lf0 = os.iter().filter(|o| o.first_load_fail).count(); + let cd0 = os.iter().filter(|o| o.first_contract_diag).count(); + let rounds: f64 = { + let p: Vec = os.iter().filter(|o| o.result == "pass").map(|o| o.rounds).collect(); + if p.is_empty() { + 0.0 + } else { + p.iter().sum::() as f64 / p.len() as f64 + } + }; + let ptok: u32 = os.iter().map(|o| o.ptok).sum(); + let ctok: u32 = os.iter().map(|o| o.ctok).sum(); + md.push_str(&format!( + "| {arm} | {pass1}/{denom} | {passf}/{denom} | {lf0}/{denom} | {cd0}/{denom} | {rounds:.2} | {}({}+{}) | {infra} |\n", + ptok + ctok, + ptok, + ctok + )); + } + + md.push_str("\n## 逐例\n\n| 例 | 臂 | 结果 | 修复轮 | 首轮语法错 | 首轮契约诊断 | token(p+c) | 查询 | 备注 |\n|---|---|---|---|---|---|---|---|---|\n"); + for o in &outs { + md.push_str(&format!( + "| {} | {} | {} | {} | {} | {} | {}+{} | {} | {} |\n", + o.task, + o.arm, + o.result, + o.rounds, + if o.first_load_fail { "是" } else { "否" }, + if o.first_contract_diag { "是" } else { "否" }, + o.ptok, + o.ctok, + o.queries, + o.note.replace('|', "\\|").replace('\n', " ") + )); + } + md.push_str("\n报告由 `tests/blind_experiment.rs` 生成;材料冻结于 `tests/blind/`(任务书 + docs-bundle),判据见 `doc/roadmap/perf-validation.md` §2。\n"); + + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("doc/roadmap") + .join(format!("blind-experiment-{}-{}.md", chrono_date(), llm.model)); + std::fs::write(&path, md).unwrap(); + eprintln!("报告已写入 {}", path.display()); +} + +fn chrono_date() -> String { + if let Ok(d) = std::env::var("MARQDO_EXP_DATE") { + return d; + } + let secs = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_secs(); + let (y, m, d) = civil_from_days((secs / 86400) as i64); + format!("{y:04}-{m:02}-{d:02}") +} + +fn civil_from_days(z: i64) -> (i64, u32, u32) { + let z = z + 719468; + let era = if z >= 0 { z } else { z - 146096 } / 146097; + let doe = (z - era * 146097) as u64; + let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365; + let y = yoe as i64 + era * 400; + let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); + let mp = (5 * doy + 2) / 153; + let d = (doy - (153 * mp + 2) / 5 + 1) as u32; + let m = if mp < 10 { mp + 3 } else { mp - 9 } as u32; + (if m <= 2 { y + 1 } else { y }, m, d) +} diff --git a/tests/contract_ablation.rs b/tests/contract_ablation.rs new file mode 100644 index 0000000..d92bc4c --- /dev/null +++ b/tests/contract_ablation.rs @@ -0,0 +1,279 @@ +//! P4 实验 (c) 契约消融([perf-validation.md](../../doc/roadmap/perf-validation.md) §3): +//! 契约**只在有契约处**拦截错误值(P1:无契约 = 全动态),且不误报。 +//! +//! 四边界(调用实参 / 返回 / 表绑定 / 字段访问)× 三形态: +//! ① 带契约 + 错值 → 必拦(`contract.*`);② 带契约 + 对值 → 零误报(跑通); +//! ③ 同程序**删契约表** + 错值 → 零 `contract.*`(动态语义原样——零回归)。 + +mod common; + +use common::{diagnose, static_diags, Verify}; + +/// (边界, 形态源)——每个边界的三形态共享同一程序骨架,只动契约表与值。 +struct Boundary { + name: &'static str, + wrong: &'static str, // ① 带契约 + 错值 + code: &'static str, // ① 期望拦截码 + right: &'static str, // ② 带契约 + 对值 + bare: &'static str, // ③ 无契约 + 错值(同程序删契约表) +} + +const ARG_WRONG: &str = "\ +# main + +**结果 = > 回显 \"7\"** +*结果* + +## 回显 + +对于输入变量`n`,原样回显。 + +| 参数 | 类型 | 说明 | +|------|------|------| +| n | number | 输入值 | + +*n* +"; + +const ARG_RIGHT: &str = "\ +# main + +**结果 = > 回显 3** +*结果* + +## 回显 + +对于输入变量`n`,原样回显。 + +| 参数 | 类型 | 说明 | +|------|------|------| +| n | number | 输入值 | + +*n* +"; + +const ARG_BARE: &str = "\ +# main + +**结果 = > 回显 \"7\"** +*结果* + +## 回显 + +对于输入变量`n`,原样回显。 + +*n* +"; + +const RET_WRONG: &str = "\ +# main + +**结果 = > 整 \"hi\"** +*结果* + +## 整 + +对于输入变量`n`,原样返回。 + +| 参数 | 类型 | 说明 | +|------|------|------| +| n | any | 输入值 | + +| 返回 | 类型 | 说明 | +|------|------|------| +| | number | 固定值 | + +*n* +"; + +const RET_RIGHT: &str = "\ +# main + +**结果 = > 整 7** +*结果* + +## 整 + +对于输入变量`n`,原样返回。 + +| 参数 | 类型 | 说明 | +|------|------|------| +| n | any | 输入值 | + +| 返回 | 类型 | 说明 | +|------|------|------| +| | number | 固定值 | + +*n* +"; + +const RET_BARE: &str = "\ +# main + +**结果 = > 整 \"hi\"** +*结果* + +## 整 + +对于输入变量`n`,原样返回。 + +*n* +"; + +const BIND_WRONG: &str = "\ +# main + +| 字段 | 类型 | 可空 | +|------|------|------| +| id | number | | +| name | text | 是 | + +`用户` = +| id | name | +|------|------| +| abc | 小明 | + +*[name](`用户`)* +"; + +const BIND_RIGHT: &str = "\ +# main + +| 字段 | 类型 | 可空 | +|------|------|------| +| id | number | | +| name | text | 是 | + +`用户` = +| id | name | +|------|------| +| 1 | 小明 | + +*[name](`用户`)* +"; + +const BIND_BARE: &str = "\ +# main + +`用户` = +| id | name | +|------|------| +| abc | 小明 | + +*[name](`用户`)* +"; + +const KEY_WRONG: &str = "\ +# main + +| 字段 | 类型 | 可空 | +|------|------|------| +| id | number | | +| name | text | 是 | + +`用户` = +| id | name | +|------|------| +| 1 | 小明 | + +*[email](`用户`)* +"; + +const KEY_RIGHT: &str = "\ +# main + +| 字段 | 类型 | 可空 | +|------|------|------| +| id | number | | +| name | text | 是 | + +`用户` = +| id | name | +|------|------| +| 1 | 小明 | + +*[name](`用户`)* +"; + +const KEY_BARE: &str = "\ +# main + +`用户` = +| id | name | +|------|------| +| 1 | 小明 | + +*[email](`用户`)* +"; + +fn boundaries() -> Vec { + vec![ + Boundary { name: "call-arg", wrong: ARG_WRONG, code: "contract.arg_mismatch", right: ARG_RIGHT, bare: ARG_BARE }, + Boundary { name: "return", wrong: RET_WRONG, code: "contract.return_mismatch", right: RET_RIGHT, bare: RET_BARE }, + Boundary { name: "bind", wrong: BIND_WRONG, code: "contract.field_mismatch", right: BIND_RIGHT, bare: BIND_BARE }, + Boundary { name: "key-access", wrong: KEY_WRONG, code: "contract.unknown_key", right: KEY_RIGHT, bare: KEY_BARE }, + ] +} + +#[test] +fn ablation_interception_rate_100() { + let all = boundaries(); + let total = all.len(); + let mut caught = 0; + for b in &all { + let diags = diagnose(Verify::Run(b.code), b.wrong, &format!("abl_wrong_{}", b.name)); + assert!( + diags.iter().any(|v| v["code"].as_str() == Some(b.code)), + "[{}] 带契约 + 错值必须被拦截(期望 {}): {:?}", + b.name, b.code, diags + ); + caught += 1; + } + eprintln!("契约拦截率 = {caught}/{total} = 100%"); +} + +#[test] +fn ablation_false_positive_rate_0() { + let all = boundaries(); + let total = all.len(); + for b in &all { + let run_diags = diagnose(Verify::Run(""), b.right, &format!("abl_right_{}", b.name)); + assert!(run_diags.is_empty(), "[{}] 对值被误报(运行): {:?}", b.name, run_diags); + let static_diags = static_diags(b.right); + assert!( + static_diags.is_empty(), + "[{}] 对值被误报(静态): {:?}", + b.name, + static_diags + ); + } + eprintln!("契约误报率 = 0/{total} = 0%"); +} + +#[test] +fn ablation_no_contract_zero_regression() { + // 无契约路径:同程序删掉契约表 + 错值 ⇒ 零 contract.*(动态语义原样)。 + // key-access 的动态语义是经典 `missing map key` 运行错——也必须是非契约诊断。 + let all = boundaries(); + let total = all.len(); + for b in &all { + let diags = diagnose(Verify::Run(""), b.bare, &format!("abl_bare_{}", b.name)); + assert!( + diags.iter().all(|v| !v["code"].as_str().unwrap_or("").starts_with("contract.")), + "[{}] 无契约路径出现契约诊断(P1 违例): {:?}", + b.name, + diags + ); + if b.name == "key-access" { + // 动态基线:经典 missing map key 错误照旧(错误不是被契约吞掉或改写)。 + assert!( + diags.iter().any(|v| v["message"] + .as_str() + .unwrap_or("") + .contains("missing map key")), + "key-access 动态基线应为经典 missing map key: {diags:?}" + ); + } + } + eprintln!("无契约零回归 = {total}/{total}"); +} diff --git a/tests/drift_drill.rs b/tests/drift_drill.rs new file mode 100644 index 0000000..60d65cd --- /dev/null +++ b/tests/drift_drill.rs @@ -0,0 +1,254 @@ +//! P4 实验 (d) 防漂移演练([perf-validation.md](../../doc/roadmap/perf-validation.md) §4): +//! **故意写错契约必报率 = 100%**——契约错了必被机器抓,绝不静默信任契约 +//! (three-problems.md §2.8「故意写错契约的金样必红」)。 +//! +//! 9 例故意漂移(类型 typo ×2 / 参数名漂移 / 错位表 / 重复表 / 四边界错值) +//! 必须全部产出 `contract.*` 诊断(静态或运行时); +//! 2 例负对照(被绑定的数据表 / 干净契约)**零误报**。 + +mod common; + +use common::{diagnose, static_diags, Verify}; + +struct Drill { + name: &'static str, + src: &'static str, + /// true = 运行期诊断;false = 静态(mlsp validate = parse + check)。 + runtime: bool, + code: &'static str, +} + +/// 类型 typo(参数表 `nubmer`)→ 静态 `contract.unknown_type`。 +const SRC_TYPO_PARAM: &str = "\ +# main + +## 加一 + +对于输入变量`n`,执行加一。 + +| 参数 | 类型 | 说明 | +|------|------|------| +| n | nubmer | 输入值 | + +*n+1* +"; + +/// 类型 typo(字段表未知对象名 `巨龙`)→ 静态 `contract.unknown_type`。 +const SRC_TYPO_FIELD: &str = "\ +# main + +| 字段 | 类型 | 可空 | +|------|------|------| +| id | 巨龙 | | + +`用户` = +| id | +|------| +| 1 | + +*[id](`用户`)* +"; + +/// 契约参数名 ≠ 升参名(`nn` vs `n`)→ 静态 `contract.param_drift`。 +const SRC_PARAM_DRIFT: &str = "\ +# main + +## 加一 + +对于输入变量`n`,执行加一。 + +| 参数 | 类型 | 说明 | +|------|------|------| +| nn | number | 输入值 | + +*n+1* +"; + +/// 错位契约表(出现在可执行语句之后)→ 静态 `contract.misplaced`。 +const SRC_MISPLACED: &str = "\ +# main + +**x=1** + +| 参数 | 类型 | 说明 | +|------|------|------| +| n | number | 输入值 | + +*x* +"; + +/// 重复契约表(两份参数表打架)→ 装载期 `contract.duplicate`。 +const SRC_DUPLICATE: &str = "\ +# main + +## 加一 + +对于输入变量`n`,执行加一。 + +| 参数 | 类型 | +|------|------| +| n | number | + +| 参数 | 类型 | +|------|------| +| n | number | + +*n+1* +"; + +/// 实参越约(参数契约 number,实参 text)→ 运行期 `contract.arg_mismatch`。 +const SRC_ARG: &str = "\ +# main + +**结果 = > 回显 \"7\"** +*结果* + +## 回显 + +对于输入变量`n`,原样回显。 + +| 参数 | 类型 | 说明 | +|------|------|------| +| n | number | 输入值 | + +*n* +"; + +/// 返回越约(返回契约 number,实际返回 text)→ 运行期 `contract.return_mismatch`。 +const SRC_RETURN: &str = "\ +# main + +**结果 = > 整 \"hi\"** +*结果* + +## 整 + +对于输入变量`n`,原样返回。 + +| 返回 | 类型 | 说明 | +|------|------|------| +| | number | 固定值 | + +*n* +"; + +/// 表绑定越约(字段 id 契约 number,单元格 abc)→ 运行期 `contract.field_mismatch`。 +const SRC_FIELD: &str = "\ +# main + +| 字段 | 类型 | 可空 | +|------|------|------| +| id | number | | +| name | text | 是 | + +`用户` = +| id | name | +|------|------| +| abc | 小明 | + +*[name](`用户`)* +"; + +/// 缺键访问(契约有 email,集合没有)→ 运行期 `contract.unknown_key`。 +const SRC_UNKNOWN_KEY: &str = "\ +# main + +| 字段 | 类型 | 可空 | +|------|------|------| +| id | number | | +| name | text | 是 | + +`用户` = +| id | name | +|------|------| +| 1 | 小明 | + +*[email](`用户`)* +"; + +/// 负对照 1:**被绑定**的 `字段|类型|可空` 数据表(web_db_migration 式)= 数据,不是契约。 +const SRC_BOUND_DATA: &str = "\ +# main + +`列说明` = +| 字段 | 类型 | 可空 | +|------|------|------| +| id | number | | +| name | text | 是 | + +*[字段]([1](`列说明`))* +"; + +/// 负对照 2:干净契约 + 对值。 +const SRC_OK: &str = "\ +# main + +**结果 = > 加一 3** +*结果* + +## 加一 + +对于输入变量`n`,期望是数字。 + +| 参数 | 类型 | 说明 | +|------|------|------| +| n | number | 输入值 | + +| 返回 | 类型 | 说明 | +|------|------|------| +| | number | 加一结果 | + +*n+1* +"; + +fn drills() -> Vec { + vec![ + Drill { name: "type-typo-param", src: SRC_TYPO_PARAM, runtime: false, code: "contract.unknown_type" }, + Drill { name: "type-typo-field", src: SRC_TYPO_FIELD, runtime: false, code: "contract.unknown_type" }, + Drill { name: "param-name-drift", src: SRC_PARAM_DRIFT, runtime: false, code: "contract.param_drift" }, + Drill { name: "misplaced-table", src: SRC_MISPLACED, runtime: false, code: "contract.misplaced" }, + Drill { name: "duplicate-table", src: SRC_DUPLICATE, runtime: true, code: "contract.duplicate" }, + Drill { name: "arg-mismatch", src: SRC_ARG, runtime: true, code: "contract.arg_mismatch" }, + Drill { name: "return-mismatch", src: SRC_RETURN, runtime: true, code: "contract.return_mismatch" }, + Drill { name: "field-mismatch", src: SRC_FIELD, runtime: true, code: "contract.field_mismatch" }, + Drill { name: "unknown-key", src: SRC_UNKNOWN_KEY, runtime: true, code: "contract.unknown_key" }, + ] +} + +#[test] +fn drift_cases_all_reported() { + let all = drills(); + let total = all.len(); + let mut caught = 0; + for d in &all { + let diags = if d.runtime { + diagnose(Verify::Run(d.code), d.src, &format!("drift_{}", d.name)) + } else { + static_diags(d.src) + }; + let hit = diags.iter().any(|v| v["code"].as_str() == Some(d.code)); + assert!( + hit, + "[{}] 故意写错的契约必须被诊断(期望 {}): {:?}", + d.name, d.code, diags + ); + caught += 1; + } + eprintln!("防漂移必报率 = {caught}/{total} = 100%"); +} + +#[test] +fn negative_controls_zero_false_positives() { + // 1. 被绑定的 `字段|类型|可空` 数据表 = 数据(web_db_migration 式)——绝不能被当契约吃掉。 + let diags = diagnose(Verify::Run(""), SRC_BOUND_DATA, "drill_neg_bound"); + assert!( + diags.iter().all(|v| !v["code"].as_str().unwrap_or("").starts_with("contract.")), + "绑定数据表被误当契约: {diags:?}" + ); + // 2. 干净契约 + 对值 ⇒ 静态零诊断、运行零诊断。 + let diags = static_diags(SRC_OK); + assert!(diags.is_empty(), "干净契约被误报(静态): {diags:?}"); + let diags = diagnose(Verify::Run(""), SRC_OK, "drill_neg_ok"); + assert!(diags.is_empty(), "干净契约被误报(运行): {diags:?}"); + eprintln!("负对照误报 = 0/2 = 0%"); +} diff --git a/tests/mlsp.rs b/tests/mlsp.rs index 2536da8..f0074f5 100644 --- a/tests/mlsp.rs +++ b/tests/mlsp.rs @@ -33,6 +33,34 @@ fn syntax_unknown_query_structured_error() { assert_eq!(resp["error"]["code"], "mlsp.no_match"); } +#[test] +fn syntax_cards_carry_rule_text_self_sufficient() { + // 「AI 不必学语法」的前提:卡片自带语义/戒律/样例原文(不必回读文档), + // 且空查询列出全部核心构造(three-problems.md §3.2「单构造戒律」)。 + let resp = call(r#"{"id":9,"method":"syntax","params":{}}"#); + assert_eq!(resp["ok"], true, "{resp}"); + let cards = resp["result"]["cards"].as_array().unwrap(); + assert_eq!( + cards.len(), + marqdo::parse::CORE_CONSTRUCTS.len(), + "空查询应列出全部核心构造: {resp}" + ); + for c in cards { + assert!( + c["rule"].as_str().unwrap_or("").len() > 2, + "卡片缺戒律原文(不可自持): {c}" + ); + assert!( + c["doc_quote"].as_str().unwrap_or("").starts_with('|'), + "卡片缺行原文: {c}" + ); + assert!( + !c["semantics"].as_str().unwrap_or("").is_empty(), + "卡片缺语义: {c}" + ); + } +} + #[test] fn locate_symbol_returns_span_and_contract() { let src = "# main\n\n## 加一\n\n对于输入变量`n`,执行加一。\n\n| 参数 | 类型 | 说明 |\n|------|------|------|\n| n | number | 输入值 |\n\n*n+1*\n";