prove: add marqdo prove (P0 emit/audit + P1 claim tables & check --proof)
Language layer (ADR 0010): - claim tables (定理|结论|前提|策略) parsed before first executable statement, extracted into Function.claims, removed from body - check --proof (default off): proof.claim_malformed / claim_ambiguous / claim_misplaced / claim_duplicate / claim_unknown_symbol / claim_unsupported / name_shadow Runtime layer (src/prove/): - ir.rs: Plan IR with stable hand-rolled JSON (schema 1) - lower.rs: subset acceptance (proof.while / proof.recursion / proof.dynamic_call), inlining for straight-line pure callees, opaque ops with effect labels, --allow-opaque whole-function downgrade - types.rs: literal-driven inference + branch confluence (proof.type_mismatch, exit 1) - emit.rs: deterministic Lean emission (Val × List Op, continuation style, -- mq: line:col anchors, «…» for dotted idents, theorem scaffolds from claims with unfold/split script) - mod.rs: prove/emit/audit/clean commands, Verdict taxonomy (error > unproved > rejected > unverified > checked > proved), exit codes 0/1/2 per design §3.3 Tests: tests/prove.rs 19 integration cases (no Lean required) + module unit tests; full suite stays green except the 3 documented env-limited failures. Docs: doc/design/prove-cli.md (§12 records deviations: result.ok/error vs drafted success/failure, Val-based run at P1, op arity, opaque effect label), doc/roadmap/prove.md, doc/adr/0010. Env fixes carried in: scratch dirs in test helpers honor CARGO_TARGET_DIR (needed on this machine's read-only target/debug).
This commit is contained in:
1 parent
6d6f580d24
commit
a11b347659
19 files changed
+6021
-13
No files matched your search
@@ -19,6 +19,9 @@
|
||||
|
||||
| 文档 | 摘要 |
|
||||
|------|------|
|
||||
| [design/prove-cli.md](design/prove-cli.md) | **Proposed:`marqdo prove` 设计**;SKILL 控制平面 → Lean 4、函数级定理表与语言习惯审查、离线判定片段、`proved`/`checked` 诚实性契约、无公理 TCB |
|
||||
| [roadmap/prove.md](roadmap/prove.md) | **Proposed:`marqdo prove` 实施路线**;P0–P3 周计划、8 类测试矩阵(单调性/一致性/不执行/子集/定理表/CLI/缓存/编码)、CI 与验收证据 |
|
||||
| [adr/0010-skill-proof-boundary.md](adr/0010-skill-proof-boundary.md) | **ADR 0010**:定理表作为契约表第四角色、可证子集封闭、Lean 为唯一 `proved` 来源、顾问式不强制 |
|
||||
| [roadmap/agent-reliability-crossrepo-2026-10-27.md](roadmap/agent-reliability-crossrepo-2026-10-27.md) | **Proposed:跨仓 Agent 可靠性开发计划**;M-A0–M-A6 ∥ Q-A0–Q-A7 排期、依赖图、F01–F20 映射、MA-T*/QA-* 验收与第一刀切片;协议真源仍见下方设计文档 |
|
||||
| [design/agent-reliability-tools-resources-2026-10-27.md](design/agent-reliability-tools-resources-2026-10-27.md) | **Proposed:智能体能力补足**;基于 `16f26d7`,增量设计错误恢复、检查点/效应账本、结构化工具、输出通道、上下文与只读资源视图;含跨仓边界、阶段计划和故障验收 |
|
||||
| [research/agent-capabilities-2026-10-27.md](research/agent-capabilities-2026-10-27.md) | **官方能力调研与源码复核**;OpenAI/Claude/Gemini/LangGraph/Deep Agents/MCP,求道当前问题 F01–F20;区分现有能力、设计推导与待实测项 |
|
||||
|
||||
@@ -0,0 +1,79 @@
|
||||
# ADR 0010: SKILL 证明边界:定理表、可证子集与顾问式判定
|
||||
|
||||
| 项目 | 约定 |
|
||||
|---|---|
|
||||
| 状态 | **Accepted(决策已定)**;实现未开始,路线见 [roadmap/prove.md](../roadmap/prove.md) |
|
||||
| 日期 | 2026-11-13 |
|
||||
| 设计 | [design/prove-cli.md](../design/prove-cli.md) |
|
||||
| 相关 | [core-surface.md](../design/core-surface.md)(不新增标记)· [layers.md](../design/layers.md)(Language 层扩表角色)· [contract.rs](../../src/contract.rs)(既有契约表提取)· [replay-policy](../../verification/replay-policy/README.md)(Lean 伴随判定先例) |
|
||||
|
||||
## 背景
|
||||
|
||||
Agent 改写 SKILL 后,人需要逐行确认"分支是否绕开审核、失败是否被吞掉"。这类**控制平面**性质适合形式化:编排是带条件的有限 DAG,没有死循环、没有指针。同时,把整个 Marqdo 当通用语言编译到 Lean 会立刻撞上字符串/JSON/浮点/IO 的语义鸿沟,收益被稀释。
|
||||
|
||||
项目已有一条 Lean 纪律:`verification/replay-policy` 用 Lean 做唯一判定,Rust 不保留第二份实现,缺伴随进程时失败关闭。本 ADR 决定把同样的纪律用于 SKILL 编排,但**降级为顾问式**:证明用于减少审核量,不作为发布门禁。
|
||||
|
||||
## 决策
|
||||
|
||||
1. **定理是契约表的第四种角色**,不是新标记。
|
||||
函数体首条可执行语句之前可放一张「定理表」(`定理 | 结论 | 前提 | 策略`),与 `参数`/`返回`/`字段` 表同槽位;解析期提取进 `Function.claims`,从 body 移除,不参与运行。核心标记计数不变,`CORE_CONSTRUCTS` 不增行;`layers.md` 的 Language 清单补记该角色。
|
||||
|
||||
2. **可证子集显式封闭**:无 `while`、无递归、无动态派发(插件、变量函数名、`code` 值调用)。越界函数被跳过(`rejected`),不降级成不透明块。外部操作是 `Env := Op → Val` 参数,不是公理;后置条件只能来自 `假设` 表并成为定理前提。
|
||||
|
||||
3. **Lean 是唯一能产生 `proved` 的判定器**。离线判定只到 `checked`,且被限制在一个极小的片段(路径枚举、轨迹、字面结果、命题组合、单变量区间),凡是离线判定为真的定理都必须同时生成 Lean 脚本。运行期若 Lean 可用则复核;离线 `checked` 而 Lean 未关闭视为内部错误(`proof.divergence`),以 Lean 为准并退出非零。
|
||||
|
||||
4. **顾问式,不强制**。默认退出码只对"作者写下的定理未被关闭"(`unproved`)与工具错误非零;缺工具链、`rejected`、`unverified` 默认 0。需要严格覆盖的调用方显式传 `--require-lean`。规范与技能手册**推荐**在发布 SKILL 前运行,但不设为门禁。
|
||||
|
||||
5. **`prove` 不执行被证程序**。只读源码、写缓存与 `--emit` 目录;这一点由测试夹具(带 `fs.write` 的函数)守住。
|
||||
|
||||
## 备选与取舍
|
||||
|
||||
| 备选 | 否决理由 |
|
||||
|---|---|
|
||||
| frontmatter `proof:` 块 | 丢函数作用域与行级锚点;多函数文件无法分派;诊断指不回具体行 |
|
||||
| `# 证明` 标题 | `#` 是对象、`##` 是函数;新增"标题=命题"破坏"标题即可调用单元"的既有习惯,还会进命名空间 |
|
||||
| ` ```proof ` 围栏 | 代码围栏必须跟在空赋值后,为写定理先造死变量,比表更别扭;且会被当作可执行值 |
|
||||
| 普通注释承载定理 | 注释不参与语义,无法可靠区分说明与定理,拿不到行锚点 |
|
||||
| 旁挂 `.proof.md` | 把真理拆成两份,违背"文档与代码同一份"的项目前提 |
|
||||
| 细化类型(refinement types) | 语义增量过大,且与既有契约表形成两份作者真相 |
|
||||
| 强制门禁(proved 才能发布) | 与"降低审核难度"的目标冲突;无 Lean 的团队会绕过工具 |
|
||||
|
||||
## 后果
|
||||
|
||||
**正面**
|
||||
|
||||
- 作者在一个地方写清"这条编排保证什么",机器可判定、行号可定位;
|
||||
- 定理表与契约表同一提取路径,`check` / `view` / `catalog` 可逐步接入,不产生第二套声明;
|
||||
- 外部依赖以假设形式显式化,证书是本项目一贯的"可复核证据";
|
||||
- 不新增核心标记,守卫测试与文档计数不膨胀。
|
||||
|
||||
**负面 / 代价**
|
||||
|
||||
- 新增一个语言层语义角色与一个 CLI 命令,需要 ADR + 测试 + 文档(本 ADR 即准入材料);
|
||||
- 离线判定器是新代码,必须长期用 Lean 语料护栏,防止"过度自信";
|
||||
- 作者可能误以为定理会在运行时生效——需要文档、`view` 与 `check` 三处反复澄清;
|
||||
- `proved` 容易被读成"整份 SKILL 安全"——README 必须写死"只对陈述负责"。
|
||||
|
||||
## 语义增量清单
|
||||
|
||||
| 新增 | 是否进运行时 | 说明 |
|
||||
|---|---|---|
|
||||
| `Function.claims` | 否 | 与 `Function.contract` 同类的声明元数据 |
|
||||
| `结果` / `轨迹` 与 `包含` / `长度` / `下标` | 否 | 仅定理作用域;与普通表达式作用域隔离 |
|
||||
| `check --proof` | 否 | 静态校验,默认关 |
|
||||
|
||||
不新增:求值规则、作用域规则、调用约定、核心标记、类型系统扩展。同名遮蔽(参数或局部变量叫 `结果`/`轨迹`)一律报 `proof.name_shadow`,不做隐式优先。
|
||||
|
||||
## 验收(摘要)
|
||||
|
||||
- 核心表面:`cargo test --test core_surface` 不变红;`CORE_CONSTRUCTS` 计数不变。
|
||||
- 单调性:语料中每条离线 `checked` 的定理,Lean 均 `proved`;分歧为 0。
|
||||
- 不执行:带 `fs.write` 的夹具在 `prove` 后无副作用。
|
||||
- 确定性:同输入两次 `emit` 字节一致。
|
||||
- 诚实性:文本、JSON、证书三处对 `checked`/`proved` 的措辞一致。
|
||||
|
||||
## 未决(不阻塞实现)
|
||||
|
||||
- `假设` 表是否需要扩展列(`来源`、`责任方`)。
|
||||
- `--all` 的聚合粒度(按文件/按函数)。
|
||||
- 证书是否需要签名,以及签名由谁持有。
|
||||
@@ -0,0 +1,776 @@
|
||||
# `marqdo prove`:SKILL 编排的 Lean 编译与顾问式证明
|
||||
|
||||
| | |
|
||||
|---|---|
|
||||
| 状态 | **计划(Proposed)· 未实现**;决策已定(§10),实施见 [roadmap/prove.md](../roadmap/prove.md) |
|
||||
| 日期 | 2026-11-13 |
|
||||
| 层归属 | **Language**:定理表角色 + `check --proof`(§7,[ADR 0010](../adr/0010-skill-proof-boundary.md))· **Runtime**:`prove` 管线(§4–§6、§8)· **Document**:`verification/skill-proof` 证据 |
|
||||
| 相关 | [core-surface.md](core-surface.md)(复用 `table` 构造,不新增标记)· [layers.md](layers.md)(准入)· [markdown-mapping-v0.3.md](markdown-mapping-v0.3.md) · [ADR 0010](../adr/0010-skill-proof-boundary.md) · [verification/replay-policy](../../verification/replay-policy/README.md)(Lean 伴随判定的先例) |
|
||||
| 目标版本 | CLI **2.8.0**(wasm / ext 不随动:`prove` 不进 wasm) |
|
||||
|
||||
---
|
||||
|
||||
## 0. 一句话与三条契约
|
||||
|
||||
`prove` 把一份 `.mq.md` 的**控制平面**(参数 → 分支 → 外部操作 → 返回值)降级成 Lean 4 定义,把作者声明的**定理**变成 Lean 定理,并尽最大努力自动关闭它们;同时输出一份可供人复核的证据(证书、假设、被拒清单)。它**不**是发布门禁,也**不**声称"过了 Lean 就绝对正确"。
|
||||
|
||||
三条契约,按优先级排列:
|
||||
|
||||
1. **诚实**:`proved` 只表示"Lean 内核接受了这条形式化陈述"。它不表示陈述写对了意图、不表示外部 API 会守约、更不表示整份 SKILL 安全。反过来,`unproved` 只表示"这次没有关闭它"——可能是定理不成立,也可能只是策略不够。
|
||||
2. **单调**:离线判定(没有 Lean 时)**只能**给出 Lean 也能给出的结论。若两者分歧,以 Lean 为准并报内部错误,绝不放绿。`checked` 永远弱于 `proved`。
|
||||
3. **不执行**:`prove` 从头到尾不运行被证程序,不产生任何效应;它只读源码、写缓存与 `--emit` 目录。
|
||||
|
||||
> 一句话给论文:*给编排文档配一张可复核的证明收据*,而不是给整个语言发一张正确性证书。
|
||||
|
||||
---
|
||||
|
||||
## 1. 定位:降低审核量,不取代审核
|
||||
|
||||
### 1.1 为什么是顾问而不是门禁
|
||||
|
||||
Agent 改写 SKILL 后,人要看的是"这一步会不会绕开审核""失败分支会不会吞掉错误"。这些恰好是控制平面命题,Lean 能帮我们把"逐行读代码"压缩成"读几条定理 + 看一眼反例"。但:
|
||||
|
||||
- 真实 SKILL 里有字符串、JSON、外部服务;把这些都形式化,成本远高于收益;
|
||||
- 形式化陈述与业务意图之间永远隔着"作者写得对不对";
|
||||
- 大多数团队没有 Lean,强制门禁只会让人绕过工具。
|
||||
|
||||
所以 `prove` 的默认行为是**报告**,不是**拦截**。规范与手册**推荐**在发布 SKILL 前跑一次,但不强求;要不要把某个状态当失败,由调用方用 `--require-lean` / `--report-only` 自己决定。
|
||||
|
||||
### 1.2 三种"绿"和两种"红"
|
||||
|
||||
| 状态 | 含义 | 由谁产生 | 能不能当"已证明" |
|
||||
|---|---|---|---|
|
||||
| `proved` | 全部定理被 Lean 内核接受 | Lean | **能**(且仅限陈述本身) |
|
||||
| `checked` | 全部定理在离线片段(§5)内判定为真,已生成对应 Lean 脚本但未运行 | 离线判定 | **不能**,只能说"离线判定通过" |
|
||||
| `unverified` | 有定理超出离线片段,且没有跑 Lean | 离线判定 | 不能 |
|
||||
| `unproved` | 至少一条定理未被关闭;若能给出反例则附见证 | Lean / 离线 | 不能;这是红灯 |
|
||||
| `rejected` | 有函数不在可证子集(`while`/递归/动态派发),已跳过 | 降级器 | 不能;这是"未覆盖",不是"错误" |
|
||||
|
||||
`rejected` 与 `unproved` 的区别很重要:前者是**工具够不着**,后者是**命题没过**。把它们混成一个红,会让"文件里有个循环"看起来像"业务逻辑错了"。
|
||||
|
||||
此外还有 `error`(编码/类型/效应/IO/超时):它不是判定结果,而是**工具或程序本身出错**,退出 1。五种判定(proved/checked/unverified/unproved/rejected)与 `error` 在 JSON 里共用 `status` 字段,但语义分组不同,报告会分开统计。
|
||||
|
||||
### 1.3 诚实性词汇表(写进 README 与 `--json`)
|
||||
|
||||
- `proved` ≠ 正确:它只对**写下来的陈述**负责,且假设 `Env` 的返回值任意、`假设` 表成立。
|
||||
- `unproved` ≠ 错误:策略失败、超时、片段外都可能;只有带 `counterexample` 字段时才是"确实不成立"。
|
||||
- `rejected` ≠ 不安全:只表示这部分没被形式化覆盖。
|
||||
- 证书不替代代码评审:它是**缩小**评审范围的工具,`audit` 会明确列出"哪些外部操作完全未知"。
|
||||
|
||||
### 1.4 非目标
|
||||
|
||||
- 不形式化解释器、字符串库、JSON、浮点、`formula`。
|
||||
- 不证明外部服务与网络;这些由 `假设` 表显式承担。
|
||||
- 不在 Agent 每次运行时跑 Lean;运行期只读证书。
|
||||
- 不自动安装 Lean;只探测并给出可执行提示。
|
||||
- 不追求"零人工":目标是让人从"读 200 行"变成"读 5 条定理 + 1 张假设表"。
|
||||
|
||||
---
|
||||
|
||||
## 2. 证明范围
|
||||
|
||||
### 2.1 义务分级
|
||||
|
||||
| 级别 | 义务 | 作者要写什么 | 谁保证 | 离线可做 |
|
||||
|---|---|---|---|---|
|
||||
| **T0 类型** | 生成的 Lean 通过内核;字段、元数、分支同型 | 无 | Lean | 部分(Rust 类型检查) |
|
||||
| **T1 结构** | 终止(无 `while`/递归 ⇒ 结构递归)、分支出口完整、返回类型符合 `返回` 契约、效应不越权(给了 `--effects` 时) | 无 | 降级器 + Lean | 是 |
|
||||
| **T2 声明** | 定理表里的业务命题 | 定理表 | Lean / 离线片段 | 是(F1–F5) |
|
||||
| **T3 契约** | 外部操作前置/后置假设下的组合推理 | `假设` 表 | Lean | 部分 |
|
||||
| **T4 一致性** | 生成语义与解释器在纯片段上同值 | 测试语料 | 差分测试 | 是 |
|
||||
|
||||
### 2.2 三条硬边界(拒绝,不降级)
|
||||
|
||||
| 构造 | 处理 | 诊断码 |
|
||||
|---|---|---|
|
||||
| `while`(`-` + 条件行) | 跳过该函数 | `proof.while` |
|
||||
| 直接/间接递归(调用图有环) | 跳过该环 | `proof.recursion` |
|
||||
| 动态派发(插件调用、变量函数名、`code` 值调用) | 跳过该调用点 | `proof.dynamic_call` |
|
||||
|
||||
被跳过的函数不参与定理,其余函数照常出证。整体状态按固定优先级合成(差者胜):`error` > `unproved` > `rejected` > `unverified` > `checked` > `proved`。`--allow-opaque <FN>` 可把某个被跳过的函数**整体**降级为不透明操作,让调用它的编排仍可证——此时它的行为完全未知,`audit` 必须列出来。
|
||||
|
||||
---
|
||||
|
||||
## 3. 命令面
|
||||
|
||||
### 3.1 命令与别名
|
||||
|
||||
```bash
|
||||
marqdo prove [PATH] # 降级 → 生成 → 离线判定 →(有 Lean 时)Lean 判定
|
||||
marqdo prove emit [PATH] -o DIR # 只生成 Lean,不判定(离线/论文/AI 取用)
|
||||
marqdo prove audit [PATH] # 只报降级结论:内联了什么、不透明了什么、拒了什么、假设了什么
|
||||
marqdo prove clean # 清 .marqdo/prove 缓存
|
||||
```
|
||||
|
||||
`prove` 带 `visible_alias = "lean"`;文档与 CI 统一写 `prove`。它与既有 `verify` 不重叠:`verify` 查知识一致性,`prove` 查控制平面命题。
|
||||
|
||||
### 3.2 参数
|
||||
|
||||
| 参数 | 默认 | 含义 |
|
||||
|---|---|---|
|
||||
| `PATH` | `index.mq.md` | 单个 `.mq.md`;目录需 `--all` |
|
||||
| `--all` | off | 目录递归(跳过 `target`/`dist`/`node_modules`/`.git`/`.marqdo`);`--max-files <N>` 默认 200 |
|
||||
| `--entry <FN>` | `main` | 入口与报告分组;不限制文件内全量证明 |
|
||||
| `--only <FN>` | — | 只证这些函数(可重复),用于增量 |
|
||||
| `--emit <DIR>` | `.marqdo/prove/<key>/Generated` | 保留生成的 Lean |
|
||||
| `--json` | off | stdout 一个 JSON 对象(§3.5);诊断走 stderr |
|
||||
| `--lean <PATH>` / `--lake <PATH>` | 探测 | 显式工具链 |
|
||||
| `--library <DIR>` | 探测 | `MarqdoProof` 库目录 |
|
||||
| `--timeout <SEC>` | 120 | 单次 Lean 调用上限 |
|
||||
| `--heartbeats <N>` | 400000 | `maxHeartbeats` |
|
||||
| `--no-cache` | off | 绕过证书与 olean 缓存 |
|
||||
| `--no-offline` | off | 跳过离线判定,只用 Lean(CI 复现/调试用) |
|
||||
| `--require-lean` | off | 严格模式:`checked`/`unverified`/`rejected` 一律返回 2 |
|
||||
| `--report-only` | off | 除工具错误外恒返回 0 |
|
||||
| `--allow-opaque <FN>` | — | 把被跳过的函数降级为不透明操作 |
|
||||
| `--effects <LIST>` | — | 与 `marqdo call --effects` 同格式;给出时检查实际调用是否越权 |
|
||||
| `--strict-types` | on | 类型无法推断即报错;`--no-strict-types` 落 `Val`(证明力下降,报告标注) |
|
||||
| `--tactic <T>` | `auto` | 定理表未写 `策略` 时的默认策略 |
|
||||
|
||||
### 3.3 状态与退出码
|
||||
|
||||
| 状态 | 退出码 | `--require-lean` | `--report-only` |
|
||||
|---|---|---|---|
|
||||
| `proved` | 0 | 0 | 0 |
|
||||
| `checked` | 0 | **2** | 0 |
|
||||
| `unverified` | 0 | **2** | 0 |
|
||||
| `rejected` | 0 | **2** | 0 |
|
||||
| `unproved` | 1 | 1 | 0 |
|
||||
| `error` / `timeout` | 1 | 1 | 1 |
|
||||
|
||||
设计理由:
|
||||
|
||||
- 缺工具链、有循环、定理在片段外,都**不是**程序的错,默认不返回非零——否则没装 Lean 的机器上 `prove` 等于不可用。
|
||||
- 默认情况下只有两种非零来源:**你写下的定理未被关闭**(1),或**工具出错**(1)。不写定理就不会有第一类失败。
|
||||
- 想要严格覆盖的团队用 `--require-lean`,把"未判定"升级成 2;CI 里加这一个参数即可。
|
||||
- 全局开关 `--report-only` 让 Agent 在探索期只看报告。
|
||||
|
||||
### 3.4 文本输出
|
||||
|
||||
```text
|
||||
$ marqdo prove skills/marqdo-release/index.mq.md
|
||||
审批 2/2 定理 proved Lean 0.8s
|
||||
plan 1/1 定理 checked 离线判定 12ms(附 Lean 脚本,未运行)
|
||||
预检 — rejected 离线 3ms proof.while L88
|
||||
prove: proved 1 · checked 1 · rejected 1
|
||||
说明: checked 不代表 Lean 已验证;安装 Lean 或传 --lean 可交由 Lean 判定。
|
||||
提示: `marqdo prove audit …` 查看降级细节与假设清单。
|
||||
```
|
||||
|
||||
失败时:
|
||||
|
||||
```text
|
||||
error[proof.claim_failed]: 定理「不该自动放行」未被关闭
|
||||
--> examples/approval.mq.md:31:3
|
||||
= 目标: (run env p).1.ok = false
|
||||
= 上下文: h : p.amount > 10000
|
||||
= 反例: 金额 = 10001 时走「人工审核」分支,结果 ok = true
|
||||
= 说明: 可能是命题不成立,也可能是策略不够;补 `策略` 或改判据后重跑。
|
||||
```
|
||||
|
||||
### 3.5 JSON(面向智能体的稳定契约)
|
||||
|
||||
一个对象,`schema` 版本化;永不交互、stdout 只有结果、诊断在 stderr、路径为相对工作目录:
|
||||
|
||||
```json
|
||||
{
|
||||
"schema": 1,
|
||||
"status": "checked",
|
||||
"file": "skills/example/index.mq.md",
|
||||
"source_sha256": "…",
|
||||
"artifact_id": "mq://…",
|
||||
"functions": [{
|
||||
"name": "审批",
|
||||
"status": "checked",
|
||||
"tier": "offline",
|
||||
"claims": [
|
||||
{"id": "大额必经人工", "status": "checked", "decided_by": "trace", "ms": 3},
|
||||
{"id": "退款必须留痕", "status": "unverified", "reason": "out_of_fragment"}
|
||||
],
|
||||
"obligations": [{"id": "terminates", "status": "passed"},
|
||||
{"id": "effects_subset", "status": "skipped", "reason": "no --effects"}]
|
||||
}],
|
||||
"lean": null,
|
||||
"assumptions": [],
|
||||
"diagnostics": [],
|
||||
"emitted": [".marqdo/prove/ab12…/Generated/Approval.lean"],
|
||||
"duration_ms": 15
|
||||
}
|
||||
```
|
||||
|
||||
`lean` 为 `null` 表示没跑;跑了则是 `{"toolchain": "...", "library_sha256": "...", "module_sha256": "...", "cache": "hit|miss"}`。`tier` ∈ `{lean, offline, none}`,标明该函数的结论来自哪一层。`status` 的取值集合固定(§1.2),Agent 可按它分支,不需要解析自然语言。
|
||||
|
||||
### 3.6 面向智能体的使用契约
|
||||
|
||||
`prove` 的主要调用者不是人,是 Agent 的循环。因此:
|
||||
|
||||
- **一次调用一个结论**:不做交互式提问,不读 TTY,不依赖环境变量之外的隐藏状态。
|
||||
- **只解析 JSON**:`--json` 的键与状态词是稳定契约(`schema` 升级才变);stdout 不混入程序输出或进度条。
|
||||
- **失败即数据**:每条诊断都有 `code` / `file` / `line` / `column` / `message`,能定位的还带 `goal`、`context`、`counterexample`、`hint`。Agent 不需要从自然语言里猜。
|
||||
- **可增量**:`--only <FN>` 只证受影响函数;证书命中让第二轮降到毫秒级。
|
||||
- **先审计再证明**:Agent 应先 `prove audit --json` 看"有多少内联、多少不透明、多少被跳过",再决定是否值得为该文件写定理。
|
||||
- **推荐循环**:写 SKILL → `check` → `prove --json` → 读 `claims[].status` → 改代码/定理/策略 → 重跑 → 把证书附进交付说明。
|
||||
|
||||
### 3.7 选择规则
|
||||
|
||||
- **文件**:显式路径;目录必须 `--all`(否则 `proof.need_all`)。
|
||||
- **函数**:文件内全部 `##` 函数默认参与;`# main` 只作分组。
|
||||
- **导入**:默认内联可判定的纯函数(§4.5),其余成为不透明操作;不递归证明被导入文件。
|
||||
- **`--all` 聚合**:逐文件出状态,整体取最差;`--json` 输出 `files: [...]`。
|
||||
|
||||
---
|
||||
|
||||
## 4. 管线
|
||||
|
||||
### 4.1 六段
|
||||
|
||||
```text
|
||||
.mq.md
|
||||
① 装载 load_module(只读,不执行)
|
||||
② 降级 AST → Plan IR:子集验收、拒绝码、span
|
||||
③ 定型 contract::Ty 驱动;未定 ⇒ 报错或 Val
|
||||
④ 生成 IR → Lean(确定性:稳定排序、无时间戳、相对路径)
|
||||
⑤ 离线判定 符号执行 + 片段判定(§5),产出 checked / 反例 / unverified
|
||||
⑥ Lean 判定 有工具链时运行;以它为准,与 ⑤ 分歧即 error
|
||||
```
|
||||
|
||||
⑤ 永远在 ⑥ 之前:离线先给快速反馈,Lean 随后确认。`--no-offline` 可只跑 ⑥。
|
||||
|
||||
### 4.2 Plan IR
|
||||
|
||||
`src/prove/ir.rs`,`serde` 序列化为 `plan.json`(版本化,缓存键的一部分,论文工具可直接消费):
|
||||
|
||||
```jsonc
|
||||
{
|
||||
"schema": 1,
|
||||
"module": "skills/example/index.mq.md",
|
||||
"source_sha256": "…",
|
||||
"functions": [{
|
||||
"name": "审批",
|
||||
"params": [{"name": "金额", "ty": {"kind": "int"}}],
|
||||
"result_ty": {"kind": "map", "fields": [["ok","bool"],["value","any"],["error","any"]]},
|
||||
"ops": [{"id": "人工审核", "effect": "network.read", "params": [["金额","int"]]}],
|
||||
"steps": [
|
||||
{"kind": "if", "cond": {"op": "gt", "args": [{"var": "金额"}, {"int": 10000}]},
|
||||
"then": [{"kind": "bind", "var": "审核", "expr": {"call": "人工审核", "args": [{"var": "金额"}]}},
|
||||
{"kind": "return", "expr": {"ctor": "result.ok", "args": [{"var": "审核"}]}}],
|
||||
"else": [{"kind": "return", "expr": {"ctor": "result.ok", "args": [{"text": "auto"}]}}],
|
||||
"span": {"line": 21, "col": 1}}],
|
||||
"claims": [{"id": "大额必经人工", "premise": null, "conclusion": "…", "tactic": null}],
|
||||
"effects": ["network.read"],
|
||||
"assumptions": []
|
||||
}]
|
||||
}
|
||||
```
|
||||
|
||||
表达式分两层:`PureExpr`(字面量、变量、算术/比较/布尔、字符串拼接与插值、列表/映射字面量、`access`、`len`、类型转换)可翻译成 Lean 项;其余一律 `Call`(不透明操作),或按 §4.3 拒绝。**没有"猜"的回退。**
|
||||
|
||||
### 4.3 接受 / 拒绝矩阵
|
||||
|
||||
| Marqdo | 处理 | 备注 |
|
||||
|---|---|---|
|
||||
| `**x = 纯表达式**` | `bind` | 类型由右值推断 |
|
||||
| `**x = [标签](调用)**` | `bind` + `Op` + `trace` | 效应来自 sema |
|
||||
| `**x**`(粗体无赋值) | `return` | 纯表达式或已内联构造器 |
|
||||
| `*语句*` / `> 调用` | 语句形式,值丢弃 | 丢弃的调用仍进 trace |
|
||||
| `1. 条件 / 2. *` | `if/else` | 条件必须是纯布尔表达式 |
|
||||
| `- [项](遍历 列表 为 项)` | `foreach`(P3) | 只接受有限列表;此前 `proof.foreach_pending` |
|
||||
| `-` + 条件 | **跳过** `proof.while` | |
|
||||
| 递归 | **跳过** `proof.recursion` | 调用图环检测 |
|
||||
| 方法调用 `` `recv`.方法 `` | 不透明操作 | 接收者不展开 |
|
||||
| `code` 值 / 插件调用 | **跳过** `proof.dynamic_call` | 不在纯片段 |
|
||||
| GFM 表绑定 | `list`/`map` 字面量 | 列长不一致已在解析期拒绝 |
|
||||
| `$$` 公式 | 不透明值(`Formula`) | 不翻译 TeX,不做推理 |
|
||||
|
||||
### 4.4 类型推断
|
||||
|
||||
起点:`参数` 表 + `返回` 表(`contract::Ty`)。合一规则:
|
||||
|
||||
- 字面量给最具体类型;`+ - * /` 要求两侧 `int`;`and/or/not` 要求 `bool`。
|
||||
- 分支合流:两臂同名变量类型必须相容,否则 `proof.type_mismatch`(带两处行号)。
|
||||
- 映射字段:返回表达式是映射字面量时得到 `structure`;是内联的 `result.ok/error`(lib/result 真实 API)时沿用 Result 形状;否则落 `Val`,此时 `结果.ok` 报 `proof.result_untyped`(提示:返回映射字面量或包成 Result)。
|
||||
- `--no-strict-types` 时未知类型落 `Val`;定理里只能做等式/成员判断,报告标注"弱类型"。
|
||||
|
||||
### 4.5 内联与不透明化
|
||||
|
||||
1. 建调用图(本文件 + 导入文件);有环即跳过该环。
|
||||
2. **内联**:被调函数(含 `lib/result` 一类纯库)满足 ①契约 `Effects: pure` ②语句数 ≤ 24 ③不含被跳过构造 ④非递归 → 展开函数体。这样 `result.ok(...)` 在 Lean 里就是 Val 映射构造(`mqResultOk`),`结果.ok` 变成可判定字段。
|
||||
3. **不透明化**:其余调用生成 `Op` 构造器 + 效应,由 `Env` 参数处理;`--allow-opaque` 可强制。
|
||||
4. `audit` 逐条列出:内联 / 不透明 / 跳过,以及每个不透明操作的效应与参数类型。
|
||||
|
||||
---
|
||||
|
||||
## 5. 离线判定(没有 Lean 也能给结论)
|
||||
|
||||
### 5.1 为什么需要
|
||||
|
||||
- 大多数开发机与 CI 没有 Lean;没有离线路径,`prove` 就只是"生成器"。
|
||||
- Agent 迭代需要毫秒级反馈,Lean 一次数百毫秒到数十秒。
|
||||
- 反例("金额 = 10001 时轨迹里没有人工审核")比 tactic 失败更有用。
|
||||
|
||||
但离线**绝不能**比 Lean 强。做法不是"相信我们的判定器",而是把它关进一个**极小的片段**,并让每条离线结论都附带 Lean 脚本。
|
||||
|
||||
### 5.2 片段 F1–F5(保守,超出即 `unverified`)
|
||||
|
||||
| 片段 | 能判定什么 | 为什么安全 |
|
||||
|---|---|---|
|
||||
| **F1 路径枚举** | 控制流是有限树(无循环/递归)⇒ 返回路径有限 | 由 §2.2 的拒绝保证 |
|
||||
| **F2 轨迹** | 每条路径的 `Op` 序列由分支决定;`包含/长度/下标` 逐路径求值 | 轨迹是语法产物,不依赖 `env` 返回值 |
|
||||
| **F3 字面结果** | 返回表达式只由字面量、参数、内联构造器组成时按结构求值 | 与 Lean 的 `mqResultOk` 形状一一对应 |
|
||||
| **F4 命题** | `and/or/not`、`=/≠` 作用于 F2/F3 的布尔结果;外部返回值上的**布尔判定**(如 `access(回执,"ok") == False`)视为自由原子,可分叉 | 自由原子只做二分、不假设原子间关系;两条分支都关闭才 `checked`,因此证明是对任意 `env` 成立的 |
|
||||
| **F5 单变量区间** | 原子 `x ⋈ c`(`c` 为整数字面量,`⋈ ∈ {<,≤,>,≥,=,≠}`);用路径条件 + 前提的上下界判定蕴含 | 单变量区间推理是线性整数算术的子集,`omega` 必然也能证 |
|
||||
|
||||
明确**不**离线判定(直接 `unverified`,不猜):多变量线性组合、非线性算术、字符串比较、外部返回值的非布尔字段(`.value` 之类)、任何需要归纳的命题。
|
||||
|
||||
### 5.3 判定过程
|
||||
|
||||
1. 符号执行函数体:状态 `Var → SymVal`(`Const` / `Param` / `OpResult` / `Unknown`),路径条件为原子列表,轨迹为 `Op` 列表。
|
||||
2. 每个 `if` 分叉两支(条件 / 其否定);每个 `Op` 调用产生一个 `OpResult` 符号(值未知,但**出现**已知)。
|
||||
3. 每个 `return` 收集 `(路径条件, 结果 SymVal, 轨迹)`。
|
||||
4. 对每条路径检查 `前提 ∧ 路径条件 ⊢ 结论`:把 `结果/轨迹` 代入后按 F2–F5 求值或判定。
|
||||
5. 全部路径关闭 ⇒ 该定理 `checked`;任一原子超出片段 ⇒ `unverified`;某条路径可满足且结论为假 ⇒ `unproved` + 反例。
|
||||
|
||||
### 5.4 证书与"单调性"
|
||||
|
||||
每条 `checked` 定理同时产出:
|
||||
|
||||
- **情形证书**:`(路径 id, 路径条件, 规范化目标, 关闭理由 ∈ {literal, hypothesis, interval, atom})`,写进 `certificate.json`;
|
||||
- **Lean 脚本**:`unfold run` 后按同一棵 `if` 树 `split_ifs`,每个叶子 `simp_all <;> omega`。离线情形树与 Lean 的 `if` 树来自同一份 IR,叶子一一对应;某个叶子离线关闭而 Lean 关不掉,就是 `proof.divergence`。
|
||||
|
||||
因此"离线判定 ⊂ Lean 判定"不是口头承诺,而是三件事:
|
||||
|
||||
1. **构造上**:F5 的推理是 `omega` 的子集,F1–F4 是 `simp`/`decide` 的子集;
|
||||
2. **运行期**:只要有 Lean,就在 ⑥ 复核;`checked` 但 Lean 未关闭 ⇒ `error[proof.divergence]`,退出 1,永不落绿;
|
||||
3. **测试上**:语料库强制 `offline_checked ⊆ lean_proved`(roadmap 测试矩阵 A1)。
|
||||
|
||||
**不夸大**:我们不说"离线判定器已被证明正确"。我们说它片段极小、保守、每条结论都带 Lean 脚本,且有运行期复核与 CI 语料强制。
|
||||
|
||||
### 5.5 反例
|
||||
|
||||
当某条路径可满足、且结论在该路径上求值为假时,从区间端点取一组参数值作为见证:
|
||||
|
||||
```text
|
||||
反例: 金额 = 10001
|
||||
路径: 金额 > 10000 → 人工审核
|
||||
结论: 结果.ok = False
|
||||
实际: 结果.ok = True(人工审核的返回值被包进 result.ok)
|
||||
```
|
||||
|
||||
反例只承认**确定性否定**:结论必须是字面 `false`,路径必须由区间证明可满足,且路径条件里**不含自由布尔原子**(否则可能凑出真实语义下不存在的组合)。任何一条不满足就退回 `unproved`(无见证)或 `unverified`,不编故事。
|
||||
|
||||
---
|
||||
|
||||
## 6. Lean 编码
|
||||
|
||||
### 6.1 产物布局
|
||||
|
||||
```text
|
||||
verification/skill-proof/ # 入仓:语义库 + 论文样例(人工评审)
|
||||
lean-toolchain # 与 replay-policy 同钉(v4.35.0)
|
||||
lakefile.lean
|
||||
MarqdoProof.lean
|
||||
MarqdoProof/{Basic,Result,Tactic}.lean
|
||||
examples/{approval,false-claim}.lean
|
||||
README.md # TCB 与"证了什么"的边界声明
|
||||
LIBRARY-SHA256 # 由构建脚本写入
|
||||
|
||||
.marqdo/prove/ # 生成物(.marqdo/ 已 gitignore)
|
||||
pkg/ # 一次性 Lake 包(库副本 + Generated/)
|
||||
<key>/plan.json module.lean certificate.json lean.log
|
||||
index.json # key → 指纹/状态/耗时
|
||||
```
|
||||
|
||||
### 6.2 无公理:操作是参数,假设是前提
|
||||
|
||||
```lean
|
||||
-- 库提供(MarqdoProof/Basic.lean,节选)
|
||||
inductive Val | none | int : Int → Val | str : String → Val | bool : Bool → Val
|
||||
| list : List Val → Val | map : List (String × Val) → Val
|
||||
|
||||
structure Err where code : String; message : String; operation : String
|
||||
structure Result where ok : Bool; value : Val := .none; error : Option Err := none
|
||||
|
||||
-- lib/result 的真实构造器(ok/error/value_or)映射:
|
||||
def Result.success (v : Val) : Result := { ok := true, value := v }
|
||||
def Result.failure (e : Err) : Result := { ok := false, error := some e }
|
||||
```
|
||||
|
||||
生成文件里**不出现 `axiom`,也不出现 `opaque`**:外部操作是 `Env := Op → Val` 参数,后置条件是定理的假设 `h_post`。于是 `#print axioms` 为空,定理陈述本身就把"信任了什么"写清楚。
|
||||
|
||||
### 6.3 直接风格降级(无 monad、无 `do`)
|
||||
|
||||
`StateM`/`do` 在证明里要额外展开 monad 定律,早返回的语义也容易踩坑。改用**续延式直接风格**:`compile_stmts(stmts, k)` 在 Rust 里把后续语句当续延,早返回就是"把 `k` 换成函数出口"。产出的 Lean 是纯 `let`/`if`/`pair`,`simp`/`split`/`omega` 直接可用。
|
||||
|
||||
输入(`verification/skill-proof/examples/approval.mq.md` 节选):
|
||||
|
||||
```markdown
|
||||
## 审批
|
||||
+ `金额`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| 金额 | int | 申请金额(元) |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | Result |
|
||||
|
||||
| 定理 | 结论 | 前提 | 策略 |
|
||||
|---|---|---|---|
|
||||
| 大额必经人工 | 包含(轨迹, "人工审核") | 金额 > 10000 | auto |
|
||||
|
||||
1. `金额` > 10000
|
||||
**审核 = [提交人工审核](人工审核(金额=`金额`))**
|
||||
**结果 = [保留人工审核结论](result.ok(value=`审核`))**
|
||||
2. *
|
||||
**结果 = [自动通过](result.ok(value="auto"))**
|
||||
|
||||
**结果**
|
||||
```
|
||||
|
||||
输出:
|
||||
|
||||
```lean
|
||||
import MarqdoProof
|
||||
open MarqdoProof
|
||||
|
||||
namespace Generated.Approval
|
||||
|
||||
structure Params where
|
||||
金额 : Int
|
||||
deriving Repr, DecidableEq
|
||||
|
||||
inductive Op where
|
||||
| 人工审核 (金额 : Int)
|
||||
deriving Repr, BEq
|
||||
|
||||
def Op.name : Op → String
|
||||
| .人工审核 _ => "人工审核"
|
||||
|
||||
abbrev Env := Op → Val
|
||||
|
||||
def run (env : Env) (p : Params) : Result × List Op :=
|
||||
if p.金额 > 10000 then
|
||||
let v := env (.人工审核 p.金额)
|
||||
(Result.success v, [.人工审核 p.金额])
|
||||
else
|
||||
(Result.success (.str "auto"), [])
|
||||
|
||||
theorem 大额必经人工 (env : Env) (p : Params) (h : p.金额 > 10000) :
|
||||
(run env p).2.any (fun o => o.name == "人工审核") = true := by
|
||||
unfold run
|
||||
split_ifs <;> simp_all <;> omega
|
||||
|
||||
end Generated.Approval
|
||||
```
|
||||
|
||||
要点:每步带 `-- mq: line:col` 注释;中文标识符直接可用,含点/空格的用 `«…»`;命名冲突在生成前消解。
|
||||
|
||||
### 6.4 义务与定理
|
||||
|
||||
| 项 | 形状 | 来源 |
|
||||
|---|---|---|
|
||||
| 类型检查(T0) | 文件通过内核:字段、元数、分支同型 | Lean,编译结果即证据 |
|
||||
| 终止(T1) | 无 `while`/递归 ⇒ Lean 接受为 `def` | 同上;需要 `partial` 的一律已跳过 |
|
||||
| `effects_subset` | 实际 `Op` 集合 ⊆ `--effects` 授权 | Rust 判定,写证书 `obligations` |
|
||||
| 作者定理(T2) | `∀ p, pre p → post p (run env p)` | 定理表 |
|
||||
| 假设(T3) | `h_* : ∀ …, Post …` 作为定理前提 | 假设表 |
|
||||
|
||||
违反 `effects_subset` 不是 `rejected` 而是 `error[proof.effects_exceeded]`:前者是"够不着",后者是"够得着且越权",必须区分。未给 `--effects` 时该义务记为 `skipped`,不假装通过。
|
||||
|
||||
### 6.5 策略
|
||||
|
||||
```lean
|
||||
macro "mq_auto" : tactic =>
|
||||
`(tactic| first
|
||||
| decide
|
||||
| omega
|
||||
| simp_all
|
||||
| (split <;> simp_all)
|
||||
| (split_ifs <;> simp_all <;> omega)
|
||||
| aesop)
|
||||
```
|
||||
|
||||
定理表 `策略` 列可写 `auto` / `omega` / `simp [run]` / 任意 tactic 片段;写 `none` 表示只生成不证(论文留人工证明钩子),状态记 `unverified` 而不是失败。
|
||||
|
||||
### 6.6 源码映射
|
||||
|
||||
每个语句前放 `-- mq: <line>:<col>`;`module.lean` 与 `plan.json` 同缓存。Lean 报 `Generated/X.lean:41:7: error: …` 时,驱动把 41 映射回 `.mq.md` 行,诊断指回源码,`lean_line` 放在 JSON 细节里。映射表进证书。
|
||||
|
||||
---
|
||||
|
||||
## 7. 作者面:定理表与语言习惯
|
||||
|
||||
### 7.1 语法与位置
|
||||
|
||||
表格构造**已有**(不新增核心标记),这里只给它一个新的**语义角色**:
|
||||
|
||||
```markdown
|
||||
| 定理 | 结论 | 前提 | 策略 |
|
||||
|---|---|---|---|
|
||||
| 大额必经人工 | 包含(轨迹, "人工审核") | 金额 > 10000 | auto |
|
||||
```
|
||||
|
||||
规则(与 `参数/返回/字段` 契约表同构):
|
||||
|
||||
1. 表头别名:`定理/证明/claim/theorem`;列名 `结论/conclusion`、`前提/premise`(可缺省)、`策略/tactic`(可缺省)。
|
||||
2. 位置:函数体**首条可执行语句之前**,与契约表同一槽位;提取后从 body 移除,**不参与运行**。出现在别处仍是普通表,`check --proof` 报 `proof.claim_misplaced`。
|
||||
3. 一行一条;`定理` 列是函数内唯一 id,重复即 `proof.claim_duplicate`。
|
||||
4. 结论/前提是**受限表达式**:参数、`结果`、`轨迹`、`包含/contains`、`长度/length`、`下标/index`,以及算术/比较/布尔。其他名字 → `proof.claim_unknown_symbol`(带最近建议)。
|
||||
5. 一张表如果既像契约表(有 `类型` 列)又像定理表(有 `结论` 列)→ `proof.claim_ambiguous`,不猜。
|
||||
|
||||
### 7.2 语义
|
||||
|
||||
一条定理展开为:
|
||||
|
||||
```lean
|
||||
theorem <id> (env : Env) (p : Params) (h : <前提>[p]) :
|
||||
<结论>[p, (run env p)] := by …
|
||||
```
|
||||
|
||||
- 前提在**入口状态**求值(参数),结论可引用参数、`结果`、`轨迹`。
|
||||
- 没有前提就是全称命题;`结果.ok = True` 天然表示"所有成功终止都满足"。
|
||||
- `轨迹` 有序;`包含/长度/下标` 三个谓词够表达"存在/顺序/计数",不再长大。
|
||||
- 定理是**声明**,不是代码:没有求值顺序、没有副作用、不能调用任意函数。
|
||||
|
||||
### 7.3 语言习惯审查(是否引入了多余语义)
|
||||
|
||||
这是这次设计最需要交代清楚的一节。逐条回答"会不会破坏语言习惯"。
|
||||
|
||||
#### 7.3.1 实际新增了什么
|
||||
|
||||
| 新增项 | 性质 | 是否影响运行 |
|
||||
|---|---|---|
|
||||
| `Function.claims` 元数据 | 声明(与 `Function.contract` 同类) | **否**,提取后从 body 移除 |
|
||||
| 定理作用域的两个保留名(`结果/轨迹`)与三个谓词 | 只在定理内可见的绑定 | **否**,不在普通表达式作用域 |
|
||||
| 假设表作用域的 `返回` | 只在假设表内可见的绑定 | **否** |
|
||||
| `check --proof` | 静态校验开关,默认关 | 否 |
|
||||
|
||||
除此之外没有新语法、没有新标记、没有新求值规则、没有新类型系统。
|
||||
|
||||
#### 7.3.2 没有新增什么(逐项对照)
|
||||
|
||||
| 风险项 | 结论 | 依据 |
|
||||
|---|---|---|
|
||||
| 新核心标记? | 否 | 用的是既有 GFM 表(`core-surface.md` 的 `table`);`CORE_CONSTRUCTS` 计数不变 |
|
||||
| 新求值顺序/作用域? | 否 | 定理表与契约表一样,在解析期提取,不进 AST body |
|
||||
| 新调用约定/形参? | 否 | 不要求调用者传证明参数,不给函数加隐藏形参 |
|
||||
| 新类型系统(refinement/依赖类型)? | 否 | 只在表里写命题;不做类型层扩展 |
|
||||
| 影响叙述比例/可读性? | 否 | 表是 code 构造;GitHub 渲染正常;`labels`/`narrative_ratio` 行为不变 |
|
||||
| 影响 `check` 既有诊断? | 否 | 新表头不命中 `参数/返回/字段`,`parse_contract_table` 不认领;新增校验默认关 |
|
||||
|
||||
#### 7.3.3 为什么不是别的写法
|
||||
|
||||
| 备选 | 为什么不用 |
|
||||
|---|---|
|
||||
| frontmatter `proof:` 块 | 丢函数作用域与行级锚点;一个函数一条定理时锚点落在文件头,诊断无法指回具体行;多函数文件无法分派 |
|
||||
| `# 证明` 标题 | `#` 是对象、`##` 是函数,标题即单元——新增"标题=命题"会破坏"标题即可调用单元"这条既有习惯,且会进命名空间 |
|
||||
| 围栏块(` ```proof ` 语言标签) | 代码围栏必须跟在空赋值后(`x =` + fence),否则解析器直接报错;为了写定理先造一个死变量,比表更别扭,且该值会被当作可执行值 |
|
||||
| 注释里写定理(`<!-- -->`) | 注释不参与语义,也拿不到行锚点;工具无法可靠区分"说明"与"定理" |
|
||||
| 单独 `.proof.md` 旁挂文件 | 真理被拆成两份,正是这个项目一直在避免的事("代码与文档同一份") |
|
||||
| 类型即契约(refinement) | 语义增量太大,且现有契约表已经承担类型声明;再来一套会形成"两份作者真相" |
|
||||
|
||||
函数级表格是最符合本项目习惯的:**声明与函数同址、可定位、可校验、不可执行**——这正是 `参数/返回/字段` 表已经建立的模式。
|
||||
|
||||
#### 7.3.4 命名冲突与遮蔽
|
||||
|
||||
- 定理作用域里 `结果`/`轨迹`、假设作用域里 `返回` 是保留名。若函数有形参或局部变量同名,`check --proof` 报 `proof.name_shadow`(错误),要求改名——**不**做隐式优先,避免"同名不同义"。
|
||||
- 谓词名 `包含/长度/下标` 若与用户函数同名,同样报 `proof.name_shadow`,不做静默覆盖。
|
||||
|
||||
#### 7.3.5 仍然存在的风险与护栏
|
||||
|
||||
| 风险 | 说明 | 护栏 |
|
||||
|---|---|---|
|
||||
| "定理像代码"的错觉 | 作者可能以为 `结果.ok = False` 会在运行时求值 | 文档措辞统一为"声明";`view` 渲染成定理卡片;`check` 提示不可运行位置 |
|
||||
| 定理表长出第二门语言 | 有人想写量词、自定义谓词、调用函数 | 谓词集合封闭(3 个);超出即 `proof.claim_unsupported`;ADR 改集合需重新评审 |
|
||||
| 定理与代码漂移 | 改了分支但没改定理 | 定理锚定行号;`check --proof` 校验引用的变量仍存在;`prove` 每次重证 |
|
||||
| 定理变成装饰 | 写了 `策略 none` 或永远 `unverified` | `audit` 统计"声明/已判定/未判定";证书只记录实际判定结果 |
|
||||
| 表被误当数据表 | 普通文档表恰好叫 `定理` | 只有表头命中且列形正确才认领;两列的"定理/说明"表仍是普通表 |
|
||||
|
||||
结论:**语义增量被压到三条声明级绑定,且不进入运行时**。它没有引入新的编程习惯,只是把"契约表"这一既有习惯扩展到"命题"。
|
||||
|
||||
### 7.4 假设表(T3)
|
||||
|
||||
外部操作默认完全未知。要让"只要银行返回失败,我们就不会记账"这类推理成立,把假设写成表:
|
||||
|
||||
```markdown
|
||||
| 假设 | 前置 | 后置 |
|
||||
|---|---|---|
|
||||
| 银行.转账 | 金额 > 0 | 返回.ok = True |
|
||||
```
|
||||
|
||||
- 表头 `假设/assumption`;`操作` 列是调用显示名(`库.成员`)。
|
||||
- 前置在实参上求值;后置在 `返回`(操作返回值)上求值;支持 `=/≠/包含/长度` 与 `返回.ok`(映射字段读取的语法糖)。
|
||||
- 生成 Lean 时不是公理,而是**定理前提**:`h_转账 : ∀ a, a > 0 → (env (.转账 a)).field? "ok" = some (.bool true)`。
|
||||
- 无法定型的后置 → `proof.assumption_untyped`(提示改成等式或补返回契约)。
|
||||
- `audit` 与证书 `assumptions` 一一对应。
|
||||
|
||||
### 7.5 与 `check` / `view` / `catalog`
|
||||
|
||||
- `check`:新增 `--proof`(**默认关**,保持既有性能),校验表形、名字、片段;不跑 Lean。
|
||||
- `view`:定理表渲染成"已声明定理"卡片;有证书时附状态徽标(`proved`/`checked`/`unverified`)。不触发证明。
|
||||
- `catalog`/`knowledge`:`Artifact` 增可选 `proof:` 摘要(证书哈希 + 状态 + 定理数),供 EKM 与 `reuse` 过滤;不改变现有 schema 必填项。
|
||||
|
||||
---
|
||||
|
||||
## 8. 工程落点
|
||||
|
||||
### 8.1 新增 / 修改文件
|
||||
|
||||
| 文件 | 变更 |
|
||||
|---|---|
|
||||
| `src/prove/mod.rs` | API、状态机、报告聚合 |
|
||||
| `src/prove/ir.rs` | Plan IR + 规范化 JSON + 指纹 |
|
||||
| `src/prove/lower.rs` | AST → IR、子集验收、拒绝码、内联 |
|
||||
| `src/prove/types.rs` | 类型推断与合一 |
|
||||
| `src/prove/emit.rs` | IR → Lean(确定性、命名消解、span 注释、脚本生成) |
|
||||
| `src/prove/offline.rs` | 符号执行、F1–F5 判定、反例 |
|
||||
| `src/prove/driver.rs` | 工具链探测、Lake 包、`lean` 调用、超时、诊断映射 |
|
||||
| `src/prove/cache.rs` | 证书、`index.json`、失效判定 |
|
||||
| `src/prove/report.rs` | 文本 / `--json` 渲染 |
|
||||
| `src/ast.rs` | `Function.claims: Vec<Claim>` |
|
||||
| `src/claim.rs`(或并入 `contract.rs`) | 定理表提取与校验 |
|
||||
| `src/parse/mod.rs` | 定理表提取入口(首条可执行语句前) |
|
||||
| `src/check.rs` | `--proof` |
|
||||
| `src/main.rs` | `Commands::Prove`、`ProveAction`、json_errors |
|
||||
| `src/lib.rs` | `pub mod prove;` |
|
||||
| `verification/skill-proof/**` | Lean 库、样例、`LIBRARY-SHA256`、README |
|
||||
| `tests/prove.rs` + `tests/prove/**` + `tests/prove_lean.rs` | 集成测试、夹具、Lean 语料(独立目标) |
|
||||
| `.github/workflows/proof.yml` | elan + `lake build` + 语料门禁 |
|
||||
|
||||
不新增 crate 依赖(`serde_json`、`sha2`、`anyhow` 已在);Lean 侧零依赖(只用 Std)。
|
||||
|
||||
### 8.2 API
|
||||
|
||||
```rust
|
||||
pub struct ProveOptions {
|
||||
pub entry: Option<String>,
|
||||
pub only: Vec<String>,
|
||||
pub allow_opaque: Vec<String>,
|
||||
pub emit_dir: Option<PathBuf>,
|
||||
pub effects: Option<String>,
|
||||
pub strict_types: bool,
|
||||
pub offline: bool,
|
||||
pub timeout: Duration,
|
||||
pub heartbeat: u64,
|
||||
pub require_lean: bool,
|
||||
pub report_only: bool,
|
||||
pub no_cache: bool,
|
||||
pub lean: Option<PathBuf>,
|
||||
pub library: Option<PathBuf>,
|
||||
}
|
||||
|
||||
pub enum Verdict { Proved, Checked, Unverified, Unproved, Rejected, Error }
|
||||
|
||||
pub fn prove_path(path: &Path, opts: &ProveOptions) -> Result<Report>;
|
||||
pub fn emit_path(path: &Path, out: &Path) -> Result<EmitReport>; // 不判定
|
||||
pub fn audit_path(path: &Path) -> Result<AuditReport>; // 不判定
|
||||
```
|
||||
|
||||
`main.rs` 只做参数搬运与退出码映射(与 `Commands::Verify` 同风格)。
|
||||
|
||||
### 8.3 缓存与证书
|
||||
|
||||
缓存键:`sha256(源码 ⊕ plan.json ⊕ schema ⊕ 库 sha256 ⊕ lean --version ⊕ marqdo 版本)`。证书:
|
||||
|
||||
```jsonc
|
||||
{
|
||||
"schema": 1,
|
||||
"key": "…",
|
||||
"status": "proved",
|
||||
"tier": "lean",
|
||||
"source": {"path": "skills/…", "sha256": "…", "artifact_id": "mq://…"},
|
||||
"lean": {"toolchain": "…", "library_sha256": "…", "module_sha256": "…", "axioms": []},
|
||||
"claims": [{"id": "…", "status": "proved", "decided_by": "omega"}],
|
||||
"offline": {"claims": [{"id": "…", "status": "checked", "cases": 3}]},
|
||||
"obligations": [{"id": "effects_subset", "status": "passed"}],
|
||||
"assumptions": ["银行.转账: 前置 金额 > 0;后置 返回.ok = True"],
|
||||
"span_map": {"41": "21:1"},
|
||||
"created": "2026-11-13T09:00:00Z",
|
||||
"marqdo": "2.8.0"
|
||||
}
|
||||
```
|
||||
|
||||
- 命中即跳过判定(报告标 `cache: hit`)。
|
||||
- 源文件、库、工具链任一变化即失效;暂不做部分重证。
|
||||
- 证书是**复核收据**,不是发布许可:推荐附在发布说明里,不强制。
|
||||
- `prove clean` 删 `.marqdo/prove`(`--emit` 目录不动)。
|
||||
|
||||
### 8.4 工具链与库发现
|
||||
|
||||
1. `--lean`/`--lake`;2. `MARQDO_PROOF_LEAN`/`MARQDO_PROOF_LAKE`;3. `PATH` 上的 `lake`,再 `lean`;4. 都没有 → 只跑离线,`lean: null`。
|
||||
|
||||
显式给出(flag 或环境变量)但路径不存在/不可执行 → `error[proof.lean_missing]`,**不**回退到离线:避免"我以为在跑 Lean,其实没有"。
|
||||
|
||||
库发现:`--library` → `MARQDO_PROOF_LIB` → 仓库内 `verification/skill-proof` → 安装根 `share/marqdo/proof/` → 相邻 `marqdo-proof/`。首次使用按 `LIBRARY-SHA256` 复制进 `.marqdo/prove/pkg` 并 `lake build` 一次(缓存);库哈希进证书。
|
||||
|
||||
### 8.5 环境变量
|
||||
|
||||
| 变量 | 作用 |
|
||||
|---|---|
|
||||
| `MARQDO_PROOF_LEAN` / `MARQDO_PROOF_LAKE` | 工具链路径 |
|
||||
| `MARQDO_PROOF_LIB` | 语义库目录 |
|
||||
| `MARQDO_PROOF_TIMEOUT` | 默认超时(秒) |
|
||||
| `MARQDO_PROOF_CACHE` | 缓存根(默认 `.marqdo/prove`) |
|
||||
| `MARQDO_PROOF_NO_CACHE` | 等价 `--no-cache` |
|
||||
| `MARQDO_PROOF_REQUIRE_LEAN` | 等价 `--require-lean`(CI/测试用) |
|
||||
|
||||
---
|
||||
|
||||
## 9. 测试与证据(摘要)
|
||||
|
||||
完整矩阵见 [roadmap/prove.md](../roadmap/prove.md) §6。四类必须守住的证据:
|
||||
|
||||
1. **单调性**(用户硬要求):语料库里每条离线 `checked` 的定理,Lean 都必须证出来;任何分歧 → `error[proof.divergence]`。
|
||||
2. **不执行**:带 `fs.write`/`exec` 的夹具在 `prove` 后不产生任何副作用。
|
||||
3. **确定性**:同输入两次运行,`module.lean` / `plan.json` / 证书键全等。
|
||||
4. **诚实性文案**:`checked` 与 `proved` 在文本、JSON、证书三处措辞一致,不允许出现"已验证"字样描述离线结果。
|
||||
|
||||
---
|
||||
|
||||
## 10. 已定事项
|
||||
|
||||
| # | 事项 | 结论 | 备注 |
|
||||
|---|---|---|---|
|
||||
| 1 | 命令名 | `marqdo prove` | 别名 `lean` |
|
||||
| 2 | 是否强制 | **不强制**;规范与手册推荐 | 无 `--require-lean` 时缺工具链不失败 |
|
||||
| 3 | 离线能否给结论 | 能,但只到 `checked` | 严格弱于 Lean(§5) |
|
||||
| 4 | 定理写法 | 函数级 `定理` 表 | [ADR 0010](../adr/0010-skill-proof-boundary.md) |
|
||||
| 5 | `check --proof` | 加,默认关 | |
|
||||
| 6 | 首版 `foreach` | 不做,P3 再加 | 之前 `proof.foreach_pending` |
|
||||
| 7 | 状态词 | `proved` / `checked` / `unverified` / `unproved` / `rejected` | 只有 `proved` 能说"已证明" |
|
||||
|
||||
遗留(不阻塞开工,P2 前定):`假设` 表是否也认领 `前置/后置` 之外的列(如 `来源`);`--all` 的聚合粒度(按文件还是按函数);证书是否需要签名。
|
||||
|
||||
---
|
||||
|
||||
## 11. 文档与发布清单
|
||||
|
||||
- [ ] 本文件转 `Implemented`(分阶段勾)
|
||||
- [ ] `doc/roadmap/prove.md`:里程碑、周计划、测试矩阵
|
||||
- [ ] `doc/adr/0010-skill-proof-boundary.md`:定理表角色 + 子集边界 + 顾问式定位
|
||||
- [ ] `doc/design/skill-proof-theory.md`:语义映射、定理形态、TCB 表
|
||||
- [ ] `verification/skill-proof/README.md`:构建、身份哈希、与 replay-policy 的关系
|
||||
- [ ] `README.md`:CLI 三行示例 + 状态表 + "推荐但不强制"
|
||||
- [ ] `doc/tutorial/13-命令行工具.md`:先 `emit`,再 `prove`
|
||||
- [ ] `skills/marqdo-dev/index.mq.md`:新增 `prove` 任务(推荐在发布前跑)
|
||||
- [ ] `skills/marqdo/reference.md`:定理表语法速查
|
||||
- [ ] `CHANGELOG.md`:2.8.0;「核心表面 Δ:无(表格新增语义角色:定理)」
|
||||
- [ ] `.github/workflows/proof.yml`;`.gitignore` 已含 `.marqdo/`
|
||||
- [ ] 发版手册:推荐附证书哈希,不设为硬门禁
|
||||
|
||||
---
|
||||
|
||||
## 12. 实现状态与偏差记录(P0/P1 落地时修订)
|
||||
|
||||
| 状态 | 内容 |
|
||||
|---|---|
|
||||
| **P0 已落地** | `src/prove/`:`ir.rs`(Plan IR + 稳定 JSON)、`lower.rs`(子集验收/内联/不透明化/效应标签)、`types.rs`(字面量推断 + 分支合流 + `proof.type_mismatch`)、`emit.rs`(确定性 Lean 生成)、`mod.rs`(Report/Verdict/ProveOptions + `prove/emit/audit/clean`)。测试:`tests/prove.rs` 12 例 + 模块单元测试,全部不依赖 Lean。 |
|
||||
| **P1(Rust 侧)已落地** | 定理表提取(`ast::Function.claims` + `contract::parse_claim_table`,首条可执行语句之前,提取后移出 body);`check --proof`(默认关):`proof.claim_malformed` / `claim_ambiguous` / `claim_misplaced` / `claim_duplicate` / `claim_unknown_symbol` / `claim_unsupported` / `name_shadow`;定理脚手架生成(受限文法 → Lean `theorem` 陈述 + §7.2 策略脚本)。Lean 判定(lake/driver/cache/CI)按 roadmap P1 第 2 周继续。 |
|
||||
|
||||
### 与本文前面章节的偏差(以本表为准)
|
||||
|
||||
1. **`result.ok/error/value_or`,不是 `result.success/failure`**:设计起草时假设的库名与 `lib/result.mq.md` 真实 API 不一致,实现以真实库为准(§4.5/§6.2 示例已同步修正)。Lean 侧库提供 `Result.success/failure` 作为映射目标。
|
||||
2. **P0/P1 的 `run` 返回 `Val × List Op`**:`result.ok(...)` 内联为 Val 字面映射构造(`mqResultOk`),而非单独的 `Result` 结构。P2 起按返回契约提升为类型化 `structure Params`/`Result`(§6.2 的形态),届时定理表可直接做字段级推理。
|
||||
3. **Op 构造器带元数**:`inductive Op` 的每个构造器按首现实参个数声明 `参数1..参数N : Val`(§6.2 示例省略了这一点)。
|
||||
4. **`--allow-opaque` 的效应标签恒为 `opaque`**:即便函数声明了契约效应也不沿用——行为完全未知时引用其声明只会误导 `audit` 读者(§2.2)。
|
||||
@@ -0,0 +1,409 @@
|
||||
# `marqdo prove` 实施路线(P0–P3)
|
||||
|
||||
| | |
|
||||
|---|---|
|
||||
| 状态 | **计划(Proposed)· 未开工** |
|
||||
| 日期 | 2026-11-13 |
|
||||
| 设计 | [design/prove-cli.md](../design/prove-cli.md)(命令面、离线片段、定理表、语言习惯审查) |
|
||||
| 决策 | [ADR 0010](../adr/0010-skill-proof-boundary.md)(定理表角色、子集边界、顾问式定位) |
|
||||
| 目标版本 | CLI 2.8.0 |
|
||||
| 总工期 | 6.5 人周(单人;P0+P1 共 3 周可演示) |
|
||||
|
||||
---
|
||||
|
||||
## 0. 完成定义
|
||||
|
||||
| 阶段 | 完成定义(DoD) |
|
||||
|---|---|
|
||||
| P0 | `prove emit` / `prove audit` 可跑;确定性生成;12 个夹具的降级结论稳定;`cargo test --test prove` 在**没有 Lean** 的机器上全绿 |
|
||||
| P1 | 定理表落地;有 Lean 时 `proved`,无 Lean 时至少 `unverified`;证书与源码映射可用;CI 跑通「假定理必须红」 |
|
||||
| P2 | 离线判定 `checked` 可用;语料库强制 `offline_checked ⊆ lean_proved`;反例可读;`--require-lean` 严格模式 |
|
||||
| P3 | 跨函数组合、`--all`、差分一致性;文档/教程/技能手册齐;2.8.0 发布 |
|
||||
|
||||
关键指标(P3 收口时复核):
|
||||
|
||||
- 语料 **≥ 40** 个夹具,覆盖 8 类(§6)。
|
||||
- 控制平面类定理的**离线覆盖率 ≥ 60%**(其余 `unverified`,不算失败)。
|
||||
- 冷启动(50 函数文件)**< 30s**;证书命中 **< 50ms**。
|
||||
- **单调性分歧 0 例**(语料 + CI 每次运行)。
|
||||
|
||||
---
|
||||
|
||||
## 1. 为什么先 Lean、后离线
|
||||
|
||||
离线判定器需要一把"标尺":没有 Lean 作为判据,无法知道它会不会"过度自信"。所以顺序是:
|
||||
|
||||
1. P0 先把降级与生成做确定(无判定,不会撒谎);
|
||||
2. P1 接上 Lean,得到**权威判据**与失败证据格式;
|
||||
3. P2 才写离线判定,并用 P1 的 Lean 结果做语料护栏(`offline ⊆ lean`)。
|
||||
|
||||
如果反过来,P2 的判定器会在没有标尺的情况下生长,最后很难证明它保守。
|
||||
|
||||
---
|
||||
|
||||
## 2. P0 · 骨架与确定性生成(1 周)
|
||||
|
||||
### 任务
|
||||
|
||||
| 天 | 任务 | 产物 |
|
||||
|---|---|---|
|
||||
| D1 | `Commands::Prove` + `ProveAction::{Emit,Audit,Clean}`;`--json` 外壳;`src/prove/mod.rs` 状态机骨架 | `marqdo prove --help` 正确;未知参数报 clap 错误 |
|
||||
| D2 | `ir.rs` + `lower.rs`:参数、赋值、返回、调用→`Op`、`if/else`;`while`/递归/动态调用的拒绝码 | 12 个夹具降级到 IR,`plan.json` 可读 |
|
||||
| D3 | `types.rs`:从契约表起步的推断与合一;`proof.type_mismatch` 等错误码 | 类型错误夹具给出两处行号 |
|
||||
| D4 | `emit.rs`:确定性 Lean 生成(稳定排序、无时间戳、相对路径)、中文名、`-- mq:` 注释 | 两次运行字节一致 |
|
||||
| D5 | `report.rs` + `audit`:内联/不透明/跳过三类清单;快照测试;`tests/prove.rs` | `cargo test --test prove` 无 Lean 全绿 |
|
||||
|
||||
### 验收
|
||||
|
||||
```bash
|
||||
marqdo prove emit tests/prove/fixtures/approval.mq.md -o /tmp/lean
|
||||
marqdo prove audit tests/prove/fixtures/approval.mq.md --json | jq '.functions[0].ops, .functions[0].rejected'
|
||||
# 两次 emit 的 sha256 相同
|
||||
```
|
||||
|
||||
### 明确不做
|
||||
|
||||
判定、证书、Lean 调用、定理表。P0 的 `prove` 只有 `emit`/`audit` 两个子命令可用,默认命令直接转发到 `emit` 并提示"判定将在 P1 提供"。
|
||||
|
||||
---
|
||||
|
||||
## 3. P1 · 定理表 + Lean 判定(2 周)
|
||||
|
||||
### 第 1 周:语言面与工具链
|
||||
|
||||
| 任务 | 产物 |
|
||||
|---|---|
|
||||
| ADR 0010 落定;`Function.claims`;定理表提取(首条可执行语句前,提取后移出 body) | 解析后 `claims` 非空,body 里没有该表 |
|
||||
| `check --proof`(默认关):表形、名字、片段、遮蔽 | `check` 报 `proof.claim_malformed` / `proof.name_shadow` |
|
||||
| `verification/skill-proof/`:`lean-toolchain`、`lakefile`、`Basic/Result/Tactic`、`LIBRARY-SHA256` 脚本 | `lake build` 通过 |
|
||||
| `driver.rs`:工具链探测、Lake 包、`lake env lean`、超时、stderr 解析 | 手工跑通 approval 样例 |
|
||||
| `cache.rs`:证书、`index.json`、失效 | 二次运行毫秒返回 |
|
||||
|
||||
### 第 2 周:定理语义与失败证据
|
||||
|
||||
| 任务 | 产物 |
|
||||
|---|---|
|
||||
| 结论/前提求值:参数、`结果`、`轨迹`、三个谓词 | 定理编译通过 |
|
||||
| 脚本生成:`intro` → `unfold run` → `split_ifs <;> simp_all <;> omega` | 正例 `proved` |
|
||||
| 失败解析:`unsolved goals` → 目标 + 上下文 → 映射回 `.mq.md` 行 | 假定理给出源码行与残余目标 |
|
||||
| `.github/workflows/proof.yml`:elan 钉版、`lake build`、跑 Lean 用例 | CI 绿;假定理用例必须红 |
|
||||
| 文本/JSON/退出码对齐设计文档 | 状态表逐项手测 |
|
||||
|
||||
### 验收
|
||||
|
||||
```bash
|
||||
marqdo prove tests/prove/fixtures/approval.mq.md --json | jq .status # "proved"
|
||||
marqdo prove tests/prove/fixtures/false-claim.mq.md; echo $? # 1
|
||||
PATH=/usr/bin:/bin target/debug/marqdo prove tests/prove/fixtures/approval.mq.md --json | jq .status
|
||||
# P1 阶段没有离线判定,因此是 "unverified";P2 起升级为 "checked"
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 4. P2 · 离线判定与单调性(2 周)
|
||||
|
||||
### 第 1 周:符号执行与 F1–F4
|
||||
|
||||
- `offline.rs`:符号状态(`Const/Param/OpResult/Unknown`)、路径条件、轨迹。
|
||||
- 分支分叉与返回路径收集;`if` 条件求值到符号原子。
|
||||
- F2 轨迹求值(`包含/长度/下标`)、F3 字面结果、F4 命题组合。
|
||||
- 结论:`checked` / `unverified` 两态;证书写入情形列表。
|
||||
|
||||
### 第 2 周:F5 区间、反例、护栏
|
||||
|
||||
- F5:单变量 `x ⋈ c` 的区间传播与蕴含判定(保守;不可判定即 `unverified`)。
|
||||
- 反例:路径可满足 + 结论字面假 → 端点见证值。
|
||||
- 分歧护栏:`checked` 但 Lean 未关闭 → `error[proof.divergence]`(含测试专用注入开关,见 §6 A3)。
|
||||
- 假设表(T3):前置/后置 → 定理前提;`proof.assumption_untyped`。
|
||||
- 单调性脚本:对语料逐条比对离线与 Lean 的定理状态。
|
||||
|
||||
### 验收
|
||||
|
||||
```bash
|
||||
# 无 Lean 也能给出离线结论
|
||||
PATH=/usr/bin:/bin target/debug/marqdo prove tests/prove/fixtures/approval.mq.md --json | jq .status # "checked"
|
||||
# 单调性:语料中不存在 checked 而 Lean unproved 的定理
|
||||
cargo test --test prove_lean # 需工具链
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 5. P3 · 组合与产品化(1.5 周)
|
||||
|
||||
| 任务 | 产物 |
|
||||
|---|---|
|
||||
| 跨函数内联 + assume-guarantee(调用者用被调者证书里的后置条件) | 多函数编排证明 |
|
||||
| `foreach`(有限列表,fold 编码) | Q1 夹具 |
|
||||
| `--all` 目录模式、聚合报告、`--max-files` | 仓库级报告 |
|
||||
| 差分一致性(T4):`Conformance.lean` + 解释器期望值 | CI 比对 |
|
||||
| `view` 徽标、`catalog` `proof:` 字段、MLSP `proof` 方法(可选) | 读侧可见 |
|
||||
| 文档:README、教程、两个 skill 手册、CHANGELOG、2.8.0 | 发布 |
|
||||
| 发版手册:推荐附证书(不强制) | 流程更新 |
|
||||
|
||||
### 验收
|
||||
|
||||
```bash
|
||||
marqdo prove --all skills/ --json | jq '.status, (.files|length)'
|
||||
lake build # verification/skill-proof/examples 全部通过
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 6. 测试矩阵(针对性)
|
||||
|
||||
夹具目录 `tests/prove/fixtures/`,集成测试 `tests/prove.rs`;Lean 相关用 `tests/prove_lean.rs`(独立测试目标,不进默认 `cargo test`)。
|
||||
|
||||
### A · 单调性与诚实性(最高优先级)
|
||||
|
||||
| ID | 夹具 / 操作 | 期望 | 守住什么 |
|
||||
|---|---|---|---|
|
||||
| A1 | `approval.mq.md`:`包含(轨迹,"人工审核")` | 离线 `checked`;Lean `proved` | 离线结论被 Lean 确认 |
|
||||
| A2 | `false-claim.mq.md`:大额时断言 `结果.ok = False` | `unproved`,退出 1;P2 起附反例 `金额=10001` | 假定理不被放绿 |
|
||||
| A3 | 同一夹具 + 测试注入 `--fault-inject offline-claim`(仅 debug 构建存在) | `error[proof.divergence]`,退出 1,JSON `status=="error"` | 分歧必须显式失败,不许静默以离线为准 |
|
||||
| A4 | 多变量线性命题(`金额 + 手续费 > 10000`) | 离线 `unverified`;跑 Lean 后 `proved` 或 `unproved` | 片段保守,不越界断言 |
|
||||
| A5 | 语料全量:`checked` 集合 ⊆ Lean `proved` 集合 | 集合包含成立,0 反例 | 长期单调性回归 |
|
||||
|
||||
### B · 语义一致性(T4)
|
||||
|
||||
| ID | 内容 | 期望 |
|
||||
|---|---|---|
|
||||
| B1 | 纯函数语料(算术、比较、布尔、字符串拼接、`access`、`len`) | 解释器输出 == Lean `example : f args = expected := by decide` |
|
||||
| B2 | 除零、取模零 | 与运行时错误语义一致(生成 `mq_div`/`mq_mod` 返回 Result.failure) |
|
||||
| B3 | 中文标识符 `计算器.加法`、含空格名 `多 步` | 生成 `«…»`,Lean 接受 |
|
||||
| B4 | 映射/表字面量:字段顺序、`ok` 字段读取 | Lean 结构与 Marqdo 取值一致 |
|
||||
| B5 | 负数、大整数(`i64` 边界) | 无溢出漂移;超界按契约拒绝 |
|
||||
|
||||
### C · 不执行(安全)
|
||||
|
||||
| ID | 夹具 | 期望 |
|
||||
|---|---|---|
|
||||
| C1 | 函数里调 `fs.write`、`fs.make_dirs` | `prove` 后目标路径不存在 |
|
||||
| C2 | 函数里调 `print` | stdout **只有** `prove` 的报告;没有程序输出 |
|
||||
| C3 | `--emit` 到只读目录 | 清晰 IO 错误,退出 1,不 panic |
|
||||
|
||||
### D · 子集与拒绝
|
||||
|
||||
| ID | 夹具 | 期望 |
|
||||
|---|---|---|
|
||||
| D1 | `while` 循环 | `proof.while`,行号准确;整体 `rejected`,退出 0 |
|
||||
| D2 | 自递归 + 互递归 | `proof.recursion`,列出环上函数名 |
|
||||
| D3 | 插件/动态调用 | `proof.dynamic_call` |
|
||||
| D4 | 未定型变量(strict) | `proof.type_mismatch`,两处行号 |
|
||||
| D5 | 同上 + `--no-strict-types` | 落 `Val`,报告标"弱类型",不报错 |
|
||||
| D6 | `--allow-opaque 预检` | 该函数列为不透明操作,调用者仍可证 |
|
||||
|
||||
### E · 定理表
|
||||
|
||||
| ID | 夹具 | 期望 |
|
||||
|---|---|---|
|
||||
| E1 | 未知名字 `审批人.ok` | `proof.claim_unknown_symbol` + 最近建议 |
|
||||
| E2 | 重复 id | `proof.claim_duplicate` |
|
||||
| E3 | 参数名 `结果` 遮蔽保留名 | `proof.name_shadow` |
|
||||
| E4 | `策略 none` | 定理生成、不证;状态 `unverified`,不是失败 |
|
||||
| E5 | 非法策略片段 `策略 nonsense` | `proof.claim_failed` 带 Lean 原始错误,不 panic |
|
||||
| E6 | 缺 `结论` 列 / 表在语句之后 | `proof.claim_malformed` / `proof.claim_misplaced`(`check --proof`) |
|
||||
| E7 | 两列「定理 / 说明」普通表 | 不认领,`check --proof` 不报 |
|
||||
| E8 | `假设` 表:`返回.ok = True` 用于分支判断 | Lean `proved`;证书 `assumptions` 有该条 |
|
||||
|
||||
### F · CLI / JSON / 退出码
|
||||
|
||||
| ID | 操作 | 期望 |
|
||||
|---|---|---|
|
||||
| F1 | 各状态夹具 | 退出码 == 设计表(0/0/0/0/1/1) |
|
||||
| F2 | `--report-only` on A2 | 退出 0,状态仍 `unproved` |
|
||||
| F3 | `--require-lean` 且 `PATH` 无 lean | 退出 2,`status=="unverified"` |
|
||||
| F4 | `--json` | 键集合与类型快照;`schema==1`;无绝对路径 |
|
||||
| F5 | 目录不带 `--all` | `proof.need_all`,退出 1 |
|
||||
| F6 | `prove clean` | `.marqdo/prove` 消失;`--emit` 目录保留 |
|
||||
|
||||
### G · 缓存与确定性
|
||||
|
||||
| ID | 操作 | 期望 |
|
||||
|---|---|---|
|
||||
| G1 | 连续两次 `prove emit` | `module.lean`、`plan.json` 字节相同 |
|
||||
| G2 | 假 `lean` 脚本写日志;连续两次 `prove` | 日志只有 1 行(第二次命中缓存) |
|
||||
| G3 | 改源码一个字符 | 证书键变化,重新判定 |
|
||||
| G4 | 改库文件(模拟 `LIBRARY-SHA256` 变化) | 缓存失效 |
|
||||
| G5 | 手工损坏 `certificate.json` | `proof.cache_corrupt`;重算或退出 1,不读坏证书 |
|
||||
|
||||
### H · 编码边角
|
||||
|
||||
| ID | 内容 | 期望 |
|
||||
|---|---|---|
|
||||
| H1 | 空 else、两臂都早返回 | 生成退化正确,Lean 通过 |
|
||||
| H2 | 不可达分支(`1. False`) | `audit` 标 warning;不阻塞 |
|
||||
| H3 | 字符串含引号/换行/中文 | 转义正确,Lean 字面量等值 |
|
||||
| H4 | 0 参数、0 语句函数 | 生成 `def run := ...` 合法 |
|
||||
| H5 | 参数默认值 | 与契约默认一致;Lean 用显式值代入 |
|
||||
|
||||
---
|
||||
|
||||
### 关键夹具草稿(P0 落盘到 `tests/prove/fixtures/`)
|
||||
|
||||
正例(轨迹命题,A1):
|
||||
|
||||
```markdown
|
||||
## 审批
|
||||
+ `金额`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| 金额 | int | 申请金额(元) |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | Result |
|
||||
|
||||
| 定理 | 结论 | 前提 | 策略 |
|
||||
|---|---|---|---|
|
||||
| 大额必经人工 | 包含(轨迹, "人工审核") | 金额 > 10000 | auto |
|
||||
|
||||
1. `金额` > 10000
|
||||
**审核 = [提交人工审核](人工审核(金额=`金额`))**
|
||||
**结果 = [保留人工审核结论](result.ok(value=`审核`))**
|
||||
2. *
|
||||
**结果 = [自动通过](result.ok(value="auto"))**
|
||||
|
||||
**结果**
|
||||
```
|
||||
|
||||
反例(A2):同构文件,只把定理换成
|
||||
|
||||
```markdown
|
||||
| 定理 | 结论 | 前提 | 策略 |
|
||||
|---|---|---|---|
|
||||
| 不该自动放行 | 结果.ok = False | 金额 > 10000 | auto |
|
||||
```
|
||||
|
||||
期望 `unproved`、退出 1;P2 起附反例 `金额 = 10001`。
|
||||
|
||||
不执行(C1):
|
||||
|
||||
```markdown
|
||||
## 落盘
|
||||
+ `path`
|
||||
|
||||
**written = [真的写一个文件](fs.write_text(path=`path`, text="证明工具不该执行我"))**
|
||||
|
||||
**written**
|
||||
```
|
||||
|
||||
跑 `prove` 后指定路径必须不存在;`prove` 只做降级与生成。
|
||||
|
||||
拒绝(D1):
|
||||
|
||||
```markdown
|
||||
## 倒计时
|
||||
+ `n`
|
||||
|
||||
- `n` > 0
|
||||
**n = n - 1**
|
||||
|
||||
**n**
|
||||
```
|
||||
|
||||
期望 `proof.while`,整体 `rejected`、退出 0(若没有别的未关闭定理)。
|
||||
|
||||
遮蔽(E3):
|
||||
|
||||
```markdown
|
||||
## 遮蔽
|
||||
+ `结果`
|
||||
|
||||
| 定理 | 结论 |
|
||||
|---|---|
|
||||
| 读结果 | 结果.ok = True |
|
||||
```
|
||||
|
||||
参数名与保留名冲突 → `proof.name_shadow`,要求改名,不做隐式优先。
|
||||
|
||||
---
|
||||
|
||||
## 7. 验收证据(可直接粘进 PR)
|
||||
|
||||
```bash
|
||||
# 1) 离线可用(把 PATH 收窄到没有 lean)
|
||||
PATH=/usr/bin:/bin target/debug/marqdo prove tests/prove/fixtures/approval.mq.md --json | jq -r .status
|
||||
# checked
|
||||
|
||||
# 2) 有 Lean 时升级为证明
|
||||
target/debug/marqdo prove tests/prove/fixtures/approval.mq.md --json | jq -r .status
|
||||
# proved
|
||||
|
||||
# 3) 假定理必须红,且给出行号
|
||||
target/debug/marqdo prove tests/prove/fixtures/false-claim.mq.md; echo "exit=$?"
|
||||
# error[proof.claim_failed] … --> false-claim.mq.md:31:3
|
||||
# exit=1
|
||||
|
||||
# 4) 单调性(语料)
|
||||
cargo test --test prove_lean -- --nocapture
|
||||
# offline_checked=37 lean_proved=37 divergences=0
|
||||
|
||||
# 5) 不执行
|
||||
rm -f /tmp/mq-prove-should-not-exist
|
||||
target/debug/marqdo prove tests/prove/fixtures/side-effect.mq.md
|
||||
test ! -e /tmp/mq-prove-should-not-exist && echo "no side effect"
|
||||
|
||||
# 6) 确定性
|
||||
a=$(target/debug/marqdo prove emit tests/prove/fixtures/approval.mq.md -o /tmp/a && sha256sum /tmp/a/Generated/Approval.lean)
|
||||
b=$(target/debug/marqdo prove emit tests/prove/fixtures/approval.mq.md -o /tmp/b && sha256sum /tmp/b/Generated/Approval.lean)
|
||||
[ "${a%% *}" = "${b%% *}" ] && echo deterministic
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 8. CI 设计
|
||||
|
||||
```yaml
|
||||
# .github/workflows/proof.yml(示意;action 版本以仓库既有 workflow 为准)
|
||||
jobs:
|
||||
corpus:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: dtolnay/rust-toolchain@stable
|
||||
- name: Install elan (toolchain pinned by verification/skill-proof/lean-toolchain)
|
||||
run: |
|
||||
curl -sSf https://elan.lean-lang.org/elan-init.sh | sh -s -- -y --default-toolchain none
|
||||
echo "$HOME/.elan/bin" >> "$GITHUB_PATH"
|
||||
- name: Build proof library (cache .lake)
|
||||
working-directory: verification/skill-proof
|
||||
run: lake build
|
||||
- run: cargo build --locked
|
||||
- run: cargo test --test prove --locked # 不需要 Lean 的部分
|
||||
- run: cargo test --test prove_lean --locked
|
||||
env: { MARQDO_PROOF_REQUIRE_LEAN: "1" }
|
||||
- run: bash scripts/check-proof-library.sh # LIBRARY-SHA256 与 BUILD-IDENTITY
|
||||
```
|
||||
|
||||
原则:
|
||||
|
||||
- `cargo test` **不依赖** Lean;Lean 用例在独立目标里,缺失工具链时打印 `SKIP: lean toolchain not found` 并在 `MARQDO_PROOF_REQUIRE_LEAN=1` 下转为失败。
|
||||
- 不使用 `#[ignore]` 作为成功证据(沿用 `executable-knowledge.yml` 的纪律)。
|
||||
- Lean 构建缓存 `.lake`,避免每次拉依赖。
|
||||
|
||||
---
|
||||
|
||||
## 9. 风险与回滚
|
||||
|
||||
| 风险 | 触发 | 应对 |
|
||||
|---|---|---|
|
||||
| Lean 工具链在 CI 不可用 | action 变更/网络 | 钉版本 + 缓存;`proof.yml` 失败只红该 job,不阻塞其它 |
|
||||
| 离线判定"过度自信" | 片段实现 bug | 语料 A5 强制包含关系;运行期 A3 分歧即 error |
|
||||
| 生成不确定 | HashMap 遍历顺序 | 全量 `BTreeMap`;两次 emit 字节比对进 CI |
|
||||
| 定理表被误用成数据表 | 表头重名 | 只有表头+列形同时命中才认领;`check --proof` 可关 |
|
||||
| 破坏既有 `check` 性能 | 提取逻辑 | `--proof` 默认关;提取只做一次线性扫描 |
|
||||
| 范围蔓延(想把整个语言编译过去) | 需求诱惑 | ADR 0010 写死子集;新增构造需重新评审 |
|
||||
|
||||
回滚:`prove` 是**纯增量**(新命令 + 新可选表角色);删除命令与 `Function.claims` 字段即可回到现状,已有 `.mq.md` 不受影响(定理表在无 `prove` 的旧版本里只是普通表格)。
|
||||
|
||||
---
|
||||
|
||||
## 10. 不做清单(本版本)
|
||||
|
||||
- `while`、递归、动态派发的形式化(拒绝而非近似)。
|
||||
- 字符串/JSON/浮点/公式库的语义建模。
|
||||
- 自动修复不成立的定理。
|
||||
- 证明缓存的服务端共享。
|
||||
- IDE 内联证明状态(先走 `view` 徽标)。
|
||||
- 强制门禁:任何"必须 proved 才能发布"的默认行为。
|
||||
+16
@@ -95,6 +95,22 @@ pub struct Function {
|
||||
pub contract: Option<crate::contract::Contract>,
|
||||
/// 集合契约(T2.1):变量名 → 字段契约(紧邻 `` `名` = `` 绑定之前的文档表)。
|
||||
pub var_contracts: HashMap<String, crate::contract::Contract>,
|
||||
/// 定理表(ADR 0010):函数级命题声明;首条可执行语句之前提取,不参与运行。
|
||||
pub claims: Vec<Claim>,
|
||||
}
|
||||
|
||||
/// 一条定理声明(设计 §7.1):`| 定理 | 结论 | 前提 | 策略 |` 的一行。
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Claim {
|
||||
/// 定理 id(函数内唯一;重复由 `check --proof` 报 `proof.claim_duplicate`)。
|
||||
pub id: String,
|
||||
/// 受限表达式文本(参数、`结果`、`轨迹`、三个谓词、算术/比较/布尔)。
|
||||
pub conclusion: String,
|
||||
pub premise: Option<String>,
|
||||
/// `auto`(默认)或 `none`;其他值由 `check --proof` 报 unsupported。
|
||||
pub tactic: Option<String>,
|
||||
/// 表行所在行号(锚定漂移检测)。
|
||||
pub line: u32,
|
||||
}
|
||||
|
||||
impl Function {
|
||||
|
||||
+13
-2
@@ -23,14 +23,17 @@ use crate::load;
|
||||
|
||||
/// 读取文件 + 装载(含 import)后做全量契约互查。
|
||||
pub fn check_path(path: &Path) -> Result<Vec<Diagnostic>> {
|
||||
check_path_opts(path, false)
|
||||
check_path_opts(path, false, false)
|
||||
}
|
||||
|
||||
/// `implicit_labels` enables the fuzzy M5 check (prose above `>` calls).
|
||||
///
|
||||
/// It is **off by default**: describing a call in prose is freeform, so the
|
||||
/// check is inherently ambiguous and would be noisy — opt in when you want it.
|
||||
pub fn check_path_opts(path: &Path, implicit_labels: bool) -> Result<Vec<Diagnostic>> {
|
||||
///
|
||||
/// `proof` enables the theorem-table check (`check --proof`, ADR 0010,
|
||||
/// 默认关):表形、名字、片段、遮蔽。
|
||||
pub fn check_path_opts(path: &Path, implicit_labels: bool, proof: bool) -> Result<Vec<Diagnostic>> {
|
||||
let module = load::load_module(path)?;
|
||||
let mut out = check_module(&module, Some(path));
|
||||
if implicit_labels {
|
||||
@@ -38,6 +41,9 @@ pub fn check_path_opts(path: &Path, implicit_labels: bool) -> Result<Vec<Diagnos
|
||||
out.extend(crate::label::check_implicit(&module, &source, Some(path)));
|
||||
}
|
||||
}
|
||||
if proof {
|
||||
out.extend(crate::prove::proof_check::check_proofs(&module, Some(path)));
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
@@ -213,6 +219,11 @@ fn edit_distance(a: &str, b: &str) -> usize {
|
||||
prev[b.len()]
|
||||
}
|
||||
|
||||
/// 供 `prove::proof_check` 复用的最近名建议(编辑距离 ≤ 2)。
|
||||
pub fn suggest_closest(name: &str, known: &[String]) -> Option<String> {
|
||||
suggest(name, known)
|
||||
}
|
||||
|
||||
fn suggest(name: &str, known: &[String]) -> Option<String> {
|
||||
let lower = name.to_ascii_lowercase();
|
||||
let mut best: Option<(usize, String)> = None;
|
||||
|
||||
+162
@@ -265,6 +265,117 @@ const TYPE_HEADERS: &[&str] = &["类型", "type"];
|
||||
const DESC_HEADERS: &[&str] = &["说明", "描述", "备注", "注释", "desc", "description"];
|
||||
const NULLABLE_HEADERS: &[&str] = &["可空", "nullable", "optional"];
|
||||
|
||||
// ---------- 定理表识别(ADR 0010 / 设计 §7.1) ----------
|
||||
|
||||
/// 定理表头(第一列)词表:`定理/证明/claim/theorem`。
|
||||
pub const CLAIM_NAME_HEADERS: &[&str] = &["定理", "证明", "claim", "theorem"];
|
||||
/// 结论列词表(必填列)。
|
||||
pub const CLAIM_CONCLUSION_HEADERS: &[&str] = &["结论", "conclusion"];
|
||||
/// 前提列词表(可缺省)。
|
||||
pub const CLAIM_PREMISE_HEADERS: &[&str] = &["前提", "premise", "assumes"];
|
||||
/// 策略列词表(可缺省)。
|
||||
pub const CLAIM_TACTIC_HEADERS: &[&str] = &["策略", "tactic"];
|
||||
|
||||
/// 表头是否命中定理表第一列(只看词,不看列形)。
|
||||
pub fn header_hits_claim(headers: &[String]) -> bool {
|
||||
find_col(headers, CLAIM_NAME_HEADERS).is_some()
|
||||
}
|
||||
|
||||
/// 定理表认领判定(设计 §7.1 规则 1/5):
|
||||
/// - `None`:表头不命中定理词表 → 普通表;
|
||||
/// - `Some(Ok(rows))`:命中且列形正确(有结论列,无 `类型` 列)→ 定理表;
|
||||
/// - `Some(Err(e))`:命中但有形状问题(歧义/行数不齐/缺名)→ `check --proof` 报。
|
||||
pub fn parse_claim_table(
|
||||
pairs: &[(String, Expr)],
|
||||
start_line: u32,
|
||||
) -> Option<Result<Vec<crate::ast::Claim>, ClaimTableError>> {
|
||||
let headers: Vec<String> = pairs.iter().map(|(k, _)| k.clone()).collect();
|
||||
if !header_hits_claim(&headers) {
|
||||
return None;
|
||||
}
|
||||
// 同时有 `类型` 列与 `结论` 列 → 歧义,不猜(§7.1 规则 5)。
|
||||
if find_col(&headers, TYPE_HEADERS).is_some()
|
||||
&& find_col(&headers, CLAIM_CONCLUSION_HEADERS).is_some()
|
||||
{
|
||||
return Some(Err(ClaimTableError {
|
||||
code: "proof.claim_ambiguous",
|
||||
message: "表同时含 `类型` 与 `结论` 列——契约表与定理表不猜,请拆开或改名".into(),
|
||||
}));
|
||||
}
|
||||
// 无结论列 → 不是定理表(两列的 `定理/说明` 是普通说明表,§7.3.5)。
|
||||
let Some(conclusion_col) = find_col(&headers, CLAIM_CONCLUSION_HEADERS) else {
|
||||
return None;
|
||||
};
|
||||
let premise_col = find_col(&headers, CLAIM_PREMISE_HEADERS);
|
||||
let tactic_col = find_col(&headers, CLAIM_TACTIC_HEADERS);
|
||||
// 第一列=定理名;若第一列不是命中列,命中列才是名字列。
|
||||
let name_col = find_col(&headers, CLAIM_NAME_HEADERS).unwrap_or(0);
|
||||
|
||||
let names = col_rows(&pairs[name_col].1).unwrap_or_default();
|
||||
let conclusions = claim_col_rows(&pairs[conclusion_col].1);
|
||||
if names.len() != conclusions.len() {
|
||||
return Some(Err(ClaimTableError {
|
||||
code: "proof.claim_malformed",
|
||||
message: format!(
|
||||
"定理/结论 列行数不一致({} vs {})",
|
||||
names.len(),
|
||||
conclusions.len()
|
||||
),
|
||||
}));
|
||||
}
|
||||
let premises = premise_col
|
||||
.map(|c| claim_col_rows(&pairs[c].1))
|
||||
.unwrap_or_default();
|
||||
let tactics = tactic_col
|
||||
.map(|c| col_rows(&pairs[c].1).unwrap_or_default())
|
||||
.unwrap_or_default();
|
||||
if !premises.is_empty() && premises.len() != names.len() {
|
||||
return Some(Err(ClaimTableError {
|
||||
code: "proof.claim_malformed",
|
||||
message: "前提 列行数与 定理 列不一致".into(),
|
||||
}));
|
||||
}
|
||||
if !tactics.is_empty() && tactics.len() != names.len() {
|
||||
return Some(Err(ClaimTableError {
|
||||
code: "proof.claim_malformed",
|
||||
message: "策略 列行数与 定理 列不一致".into(),
|
||||
}));
|
||||
}
|
||||
|
||||
let mut rows = Vec::new();
|
||||
for (i, name) in names.iter().enumerate() {
|
||||
let name = name.trim();
|
||||
if name.is_empty() {
|
||||
return Some(Err(ClaimTableError {
|
||||
code: "proof.claim_malformed",
|
||||
message: format!("定理表第 {} 行缺定理名", i + 1),
|
||||
}));
|
||||
}
|
||||
rows.push(crate::ast::Claim {
|
||||
id: name.to_string(),
|
||||
conclusion: conclusions[i].trim().to_string(),
|
||||
// 空前提单元格 = 无前提(全称命题)。
|
||||
premise: premises
|
||||
.get(i)
|
||||
.map(|s| s.trim().to_string())
|
||||
.filter(|s| !s.is_empty()),
|
||||
tactic: tactics
|
||||
.get(i)
|
||||
.map(|s| s.trim().to_string())
|
||||
.filter(|s| !s.is_empty()),
|
||||
line: start_line,
|
||||
});
|
||||
}
|
||||
Some(Ok(rows))
|
||||
}
|
||||
|
||||
/// 定理表形状错误(`check --proof` 才报;默认关)。
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct ClaimTableError {
|
||||
pub code: &'static str,
|
||||
pub message: String,
|
||||
}
|
||||
|
||||
fn norm_header(h: &str) -> String {
|
||||
h.trim().trim_matches('`').to_ascii_lowercase()
|
||||
}
|
||||
@@ -298,6 +409,57 @@ fn col_rows(e: &Expr) -> Option<Vec<String>> {
|
||||
}
|
||||
}
|
||||
|
||||
/// 定理表单元格取文本:标量直取;比较/算术/布尔表达式按 `a op b` 还原
|
||||
/// (`金额 > 10000` 这类单元格会解析成 Binary,不能因为不是标量就丢行)。
|
||||
/// 不认识的形状 → None(该行按缺失处理,`check --proof` 会报 unknown_symbol)。
|
||||
fn claim_cell_text(e: &Expr) -> Option<String> {
|
||||
if let Some(text) = cell_to_text(e) {
|
||||
return Some(text);
|
||||
}
|
||||
match e {
|
||||
Expr::Binary { op, left, right } => Some(format!(
|
||||
"{} {} {}",
|
||||
claim_cell_text(left)?,
|
||||
op_token(*op),
|
||||
claim_cell_text(right)?
|
||||
)),
|
||||
Expr::Unary { op, expr } => match op {
|
||||
crate::ast::UnaryOp::Not => Some(format!("非 ({})", claim_cell_text(expr)?)),
|
||||
crate::ast::UnaryOp::Neg => Some(format!("-({})", claim_cell_text(expr)?)),
|
||||
},
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn op_token(op: crate::ast::BinaryOp) -> &'static str {
|
||||
use crate::ast::BinaryOp as B;
|
||||
match op {
|
||||
B::Add => "+",
|
||||
B::Sub => "-",
|
||||
B::Mul => "*",
|
||||
B::Div => "/",
|
||||
B::Eq => "=",
|
||||
B::Ne => "≠",
|
||||
B::Lt => "<",
|
||||
B::Le => "≤",
|
||||
B::Gt => ">",
|
||||
B::Ge => "≥",
|
||||
B::And => "且",
|
||||
B::Or => "或",
|
||||
}
|
||||
}
|
||||
|
||||
/// 定理表列取文本(行级 None 不整列丢弃——只丢该行该列)。
|
||||
fn claim_col_rows(e: &Expr) -> Vec<String> {
|
||||
match e {
|
||||
Expr::List(items) => items
|
||||
.iter()
|
||||
.map(|item| claim_cell_text(item).unwrap_or_default())
|
||||
.collect(),
|
||||
scalar => vec![claim_cell_text(scalar).unwrap_or_default()],
|
||||
}
|
||||
}
|
||||
|
||||
fn is_nullable(raw: &str) -> bool {
|
||||
matches!(
|
||||
norm_header(raw).as_str(),
|
||||
|
||||
@@ -16,8 +16,12 @@ fn local_json(value: &Value) -> serde_json::Value {
|
||||
}
|
||||
|
||||
fn document(id: &str, source: &str) -> (PathBuf, crate::ast::Module) {
|
||||
let dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
||||
.join("target/frontend-elaboration")
|
||||
// Scratch belongs to the build target dir; honor CARGO_TARGET_DIR when set.
|
||||
let base = std::env::var_os("CARGO_TARGET_DIR")
|
||||
.map(PathBuf::from)
|
||||
.unwrap_or_else(|| PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("target"));
|
||||
let dir = base
|
||||
.join("frontend-elaboration")
|
||||
.join(format!("{id}-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let path = dir.join("main.mq.md");
|
||||
|
||||
@@ -45,6 +45,7 @@ pub mod runtime;
|
||||
pub mod workbench;
|
||||
pub mod parse;
|
||||
pub mod project;
|
||||
pub mod prove;
|
||||
pub mod repair;
|
||||
pub mod sema;
|
||||
pub mod value;
|
||||
|
||||
+166
-3
@@ -218,6 +218,10 @@ enum Commands {
|
||||
/// Parse an unmarked file with the legacy grammar for migration review.
|
||||
#[arg(long)]
|
||||
legacy_markup: bool,
|
||||
|
||||
/// Validate theorem tables (ADR 0010; 默认关): shape, symbols, shadowing
|
||||
#[arg(long)]
|
||||
proof: bool,
|
||||
},
|
||||
/// Occlusion label queries: pending stubs (built-in words) or keyword search
|
||||
Labels {
|
||||
@@ -495,6 +499,81 @@ enum Commands {
|
||||
#[command(subcommand)]
|
||||
action: WasmAction,
|
||||
},
|
||||
/// Compile SKILL orchestration to Lean 4 and (P1+) prove theorems (推荐但不强制)
|
||||
Prove {
|
||||
/// Action (default: emit + report)
|
||||
#[command(subcommand)]
|
||||
action: Option<ProveAction>,
|
||||
|
||||
/// Program path (.mq.md; default ./index.mq.md)
|
||||
#[arg(value_name = "FILE")]
|
||||
file: Option<PathBuf>,
|
||||
|
||||
/// One JSON object on stdout (agent-facing stable contract)
|
||||
#[arg(long)]
|
||||
json: bool,
|
||||
|
||||
/// Only lower/emit these functions (display path, repeatable)
|
||||
#[arg(long = "only", value_name = "FN")]
|
||||
only: Vec<String>,
|
||||
|
||||
/// Output dir for emit (default .marqdo/prove/<key>/)
|
||||
#[arg(long = "emit", short = 'o', value_name = "DIR")]
|
||||
emit_dir: Option<PathBuf>,
|
||||
|
||||
/// Don't write artifacts; report only
|
||||
#[arg(long)]
|
||||
report_only: bool,
|
||||
|
||||
/// Downgrade this function wholesale to one opaque op (repeatable)
|
||||
#[arg(long = "allow-opaque", value_name = "FN")]
|
||||
allow_opaque: Vec<String>,
|
||||
|
||||
/// Type inference is strict by default; this relaxes to Val (weaker proofs)
|
||||
#[arg(long = "no-strict-types")]
|
||||
no_strict_types: bool,
|
||||
|
||||
/// CI strict mode: unjudged statuses exit 2 (P1+)
|
||||
#[arg(long)]
|
||||
require_lean: bool,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Subcommand, Debug)]
|
||||
enum ProveAction {
|
||||
/// Generate deterministic Lean module + plan.json (no judging)
|
||||
Emit {
|
||||
#[arg(value_name = "FILE")]
|
||||
file: Option<PathBuf>,
|
||||
#[arg(long = "emit", short = 'o', value_name = "DIR")]
|
||||
emit_dir: Option<PathBuf>,
|
||||
#[arg(long)]
|
||||
json: bool,
|
||||
#[arg(long = "only", value_name = "FN")]
|
||||
only: Vec<String>,
|
||||
#[arg(long = "allow-opaque", value_name = "FN")]
|
||||
allow_opaque: Vec<String>,
|
||||
#[arg(long = "no-strict-types")]
|
||||
no_strict_types: bool,
|
||||
},
|
||||
/// Report inline/opaque/rejected classification (no judging)
|
||||
Audit {
|
||||
#[arg(value_name = "FILE")]
|
||||
file: Option<PathBuf>,
|
||||
#[arg(long)]
|
||||
json: bool,
|
||||
#[arg(long = "only", value_name = "FN")]
|
||||
only: Vec<String>,
|
||||
#[arg(long = "allow-opaque", value_name = "FN")]
|
||||
allow_opaque: Vec<String>,
|
||||
#[arg(long = "no-strict-types")]
|
||||
no_strict_types: bool,
|
||||
},
|
||||
/// Delete .marqdo/prove caches and certificates
|
||||
Clean {
|
||||
#[arg(long)]
|
||||
json: bool,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Subcommand, Debug)]
|
||||
@@ -656,7 +735,9 @@ fn main() -> ExitCode {
|
||||
let cli = Cli::parse();
|
||||
let json_errors = matches!(
|
||||
&cli.command,
|
||||
Commands::Run { json: true, .. } | Commands::Check { json: true, .. }
|
||||
Commands::Run { json: true, .. }
|
||||
| Commands::Check { json: true, .. }
|
||||
| Commands::Prove { json: true, .. }
|
||||
);
|
||||
match try_main(cli) {
|
||||
Ok(code) => ExitCode::from(code as u8),
|
||||
@@ -958,13 +1039,14 @@ fn try_main(cli: Cli) -> Result<i32> {
|
||||
implicit_labels,
|
||||
narrative_ratio,
|
||||
legacy_markup,
|
||||
proof,
|
||||
} => {
|
||||
let mut diags = if legacy_markup {
|
||||
marqdo::parse::expr::with_markup(marqdo::parse::expr::Markup::Classic, || {
|
||||
marqdo::check::check_path_opts(&file, implicit_labels)
|
||||
marqdo::check::check_path_opts(&file, implicit_labels, proof)
|
||||
})?
|
||||
} else {
|
||||
marqdo::check::check_path_opts(&file, implicit_labels)?
|
||||
marqdo::check::check_path_opts(&file, implicit_labels, proof)?
|
||||
};
|
||||
if narrative_ratio {
|
||||
diags.extend(marqdo::narrative_ratio::check_file(&file)?);
|
||||
@@ -989,6 +1071,87 @@ fn try_main(cli: Cli) -> Result<i32> {
|
||||
}
|
||||
Ok(errors.min(1))
|
||||
}
|
||||
Commands::Prove {
|
||||
action,
|
||||
file,
|
||||
json,
|
||||
only,
|
||||
emit_dir,
|
||||
report_only,
|
||||
allow_opaque,
|
||||
no_strict_types,
|
||||
require_lean,
|
||||
} => {
|
||||
// 子命令参数覆盖顶层默认;默认动作 = emit + 报告。
|
||||
let (file, action_json, action_emit, action_only, action_opaque, action_relax) =
|
||||
match &action {
|
||||
Some(ProveAction::Emit {
|
||||
file,
|
||||
emit_dir,
|
||||
json,
|
||||
only,
|
||||
allow_opaque,
|
||||
no_strict_types,
|
||||
}) => (
|
||||
file.clone(),
|
||||
*json,
|
||||
Some(emit_dir.clone()),
|
||||
only.clone(),
|
||||
allow_opaque.clone(),
|
||||
*no_strict_types,
|
||||
),
|
||||
Some(ProveAction::Audit {
|
||||
file,
|
||||
json,
|
||||
only,
|
||||
allow_opaque,
|
||||
no_strict_types,
|
||||
}) => (
|
||||
file.clone(),
|
||||
*json,
|
||||
None,
|
||||
only.clone(),
|
||||
allow_opaque.clone(),
|
||||
*no_strict_types,
|
||||
),
|
||||
Some(ProveAction::Clean { json }) => {
|
||||
let removed = marqdo::prove::clean()?;
|
||||
if *json {
|
||||
println!("{{\"ok\":true,\"removed\":{removed}}}");
|
||||
} else {
|
||||
println!("prove clean: 已删除 {removed} 项(.marqdo/prove)");
|
||||
}
|
||||
return Ok(0);
|
||||
}
|
||||
None => (file.clone(), false, Some(emit_dir.clone()), only.clone(), allow_opaque.clone(), no_strict_types),
|
||||
};
|
||||
let file = file.unwrap_or_else(|| PathBuf::from("index.mq.md"));
|
||||
// emit 目标:显式 --emit 优先;None → mod.rs 用默认 `.marqdo/prove/<key8>`。
|
||||
// audit 永不写盘;默认动作受 --report-only 控制;emit 子命令总是写盘。
|
||||
let emit_target = action_emit.flatten();
|
||||
let report_only = matches!(action, Some(ProveAction::Audit { .. }))
|
||||
|| (action.is_none() && report_only);
|
||||
let opts = marqdo::prove::ProveOptions {
|
||||
entry: None,
|
||||
only: action_only,
|
||||
allow_opaque: action_opaque,
|
||||
emit_dir: emit_target,
|
||||
strict_types: !action_relax,
|
||||
require_lean,
|
||||
report_only,
|
||||
};
|
||||
let report = marqdo::prove::prove_path(&file, &opts)?;
|
||||
for d in &report.diagnostics {
|
||||
// 诊断走 stderr(stdout 只放结果/报告)。
|
||||
eprintln!("{}", d.format_message());
|
||||
}
|
||||
if json || action_json {
|
||||
println!("{}", report.to_json());
|
||||
} else {
|
||||
print!("{}", report.to_text());
|
||||
}
|
||||
Ok(report.status.exit_code(require_lean))
|
||||
}
|
||||
Commands::Labels {
|
||||
paths,
|
||||
grep,
|
||||
|
||||
+18
-4
@@ -319,6 +319,7 @@ impl<'a> Cursor<'a> {
|
||||
dead_binds: Vec::new(),
|
||||
contract: None,
|
||||
var_contracts: std::collections::HashMap::new(),
|
||||
claims: Vec::new(),
|
||||
};
|
||||
// Prose decls pending promotion (name → optional default text).
|
||||
let mut prose_decls: Vec<(String, Option<String>, u32)> = Vec::new();
|
||||
@@ -2078,10 +2079,23 @@ fn extract_function_contract(fun: &mut Function, lines: &[ClassifiedLine]) -> Re
|
||||
let (end_line, quote) = table_quote(lines, span.line);
|
||||
let Some(parsed) = crate::contract::parse_contract_table(pairs, span.line, end_line, quote)
|
||||
else {
|
||||
// 非契约形状:普通文档/数据表 → 原样保留(P1 零回归的关键)。
|
||||
keep.push(stmt.clone());
|
||||
i += 1;
|
||||
continue;
|
||||
// 非契约形状:先试定理表(ADR 0010),再按普通表保留。
|
||||
match crate::contract::parse_claim_table(pairs, span.line) {
|
||||
// 合法定理表:只在「首个可执行行之前」生效;提取后从 body 移除。
|
||||
// 其余位置仍是普通表,由 `check --proof` 报 proof.claim_misplaced。
|
||||
Some(Ok(rows)) if prefix_zone => {
|
||||
fun.claims.extend(rows);
|
||||
i += 1;
|
||||
continue;
|
||||
}
|
||||
// 畸形/歧义/错位的定理形表:保持普通表(默认关),
|
||||
// `check --proof` 重扫 body 时报 malformed/ambiguous/misplaced。
|
||||
_ => {
|
||||
keep.push(stmt.clone());
|
||||
i += 1;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
};
|
||||
let piece = parsed?; // 契约形状但畸形 → 必产诊断(contract.malformed)
|
||||
let is_fn_contract = !piece.params.is_empty() || piece.returns.is_some();
|
||||
|
||||
@@ -0,0 +1,684 @@
|
||||
//! Lean 生成(`doc/design/prove-cli.md` §4.1 ④ / §6)。
|
||||
//!
|
||||
//! 确定性硬要求:同输入两次运行字节一致。做法:无时间戳、无绝对路径、
|
||||
//! 集合按首次出现顺序(降级本身确定)、映射键排序、浮点定长。
|
||||
//!
|
||||
//! P0 形态:参数统一 `Val`(P1 起按契约提升为 `Int`/`String` 等以配合
|
||||
//! `structure Params` 与定理表);`result.ok/error` 内联为库构造器。
|
||||
|
||||
use std::fmt::Write as _;
|
||||
|
||||
use crate::prove::ir::{
|
||||
BinOp, Expr as IrExpr, FnPlan, InterpPart, Plan, PlanTy, PureExpr, Step, UnOp,
|
||||
};
|
||||
|
||||
/// 库名(verification/skill-proof 提供;P1 落地)。
|
||||
pub const LIBRARY_IMPORT: &str = "MarqdoProof";
|
||||
|
||||
/// 生成整个文件模块。返回 `(文件名, 内容)`。
|
||||
pub fn emit_module(plan: &Plan, module_stem: &str) -> (String, String) {
|
||||
let namespace = namespace_of(module_stem);
|
||||
let mut out = String::new();
|
||||
let _ = writeln!(out, "import {LIBRARY_IMPORT}");
|
||||
let _ = writeln!(out, "open MarqdoProof");
|
||||
let _ = writeln!(out);
|
||||
let _ = writeln!(out, "-- 由 `marqdo prove emit` 生成:确定性输出,请勿手改。");
|
||||
let _ = writeln!(out, "-- 源:{}(sha256 {})", plan.module, plan.source_sha256);
|
||||
let _ = writeln!(out, "namespace Generated.{}", namespace);
|
||||
let _ = writeln!(out);
|
||||
|
||||
// 模块级 Op:所有函数的不透明操作并集(保持首次出现顺序,去重)。
|
||||
emit_op_inductive(&mut out, plan);
|
||||
let _ = writeln!(out);
|
||||
|
||||
for fun in &plan.functions {
|
||||
emit_function(&mut out, fun);
|
||||
let _ = writeln!(out);
|
||||
emit_theorems(&mut out, fun);
|
||||
let _ = writeln!(out);
|
||||
}
|
||||
|
||||
let _ = writeln!(out, "end Generated.{}", namespace);
|
||||
let file_name = format!("{namespace}.lean");
|
||||
(file_name, out)
|
||||
}
|
||||
|
||||
/// 定理脚手架(§7.2):受限文法可解析的命题 → `theorem` 陈述 + `sorry`
|
||||
fn emit_theorems(out: &mut String, fun: &FnPlan) {
|
||||
if fun.claims.is_empty() {
|
||||
return;
|
||||
}
|
||||
let fun_name = lean_ident(&fun.name);
|
||||
// 定理形参:`env 轨迹₀` + 函数形参。
|
||||
let mut binders = String::from("(env : Env) (轨迹₀ : List Op)");
|
||||
for param in &fun.params {
|
||||
let _ = write!(binders, " ({} : Val)", lean_ident(¶m.name));
|
||||
}
|
||||
for claim in &fun.claims {
|
||||
let premise_lean = claim
|
||||
.premise
|
||||
.as_deref()
|
||||
.and_then(claim_to_lean_bool);
|
||||
let conclusion_lean = claim_to_lean_bool(&claim.conclusion);
|
||||
let premise_text = match (&claim.premise, premise_lean) {
|
||||
(Some(_), Some(lean)) => format!(" (h_前提 : mqTruth {lean})"),
|
||||
_ => String::new(),
|
||||
};
|
||||
let tactic = claim.tactic.as_deref().unwrap_or("auto");
|
||||
let _ = writeln!(out, "-- 定理 {}(策略 {tactic};mq: {})", claim.id, claim.line);
|
||||
match conclusion_lean {
|
||||
Some(conclusion) => {
|
||||
let _ = writeln!(
|
||||
out,
|
||||
"theorem {} {binders}{premise_text} :",
|
||||
lean_ident(&format!("{}.{}", fun.name, claim.id))
|
||||
);
|
||||
let _ = writeln!(
|
||||
out,
|
||||
" ∀ (结果 : Val) (轨迹 : List Op),"
|
||||
);
|
||||
let _ = writeln!(
|
||||
out,
|
||||
" ({fun_name} env 轨迹₀ {} = (结果, 轨迹)) →",
|
||||
fun.params
|
||||
.iter()
|
||||
.map(|p| lean_ident(&p.name))
|
||||
.collect::<Vec<_>>()
|
||||
.join(" ")
|
||||
);
|
||||
let _ = writeln!(out, " {conclusion} := by");
|
||||
let _ = writeln!(out, " intro 结果 轨迹 h_run");
|
||||
let _ = writeln!(out, " unfold {fun_name} at h_run");
|
||||
let _ = writeln!(out, " split at h_run <;> simp_all <;> omega");
|
||||
}
|
||||
_ => {
|
||||
let _ = writeln!(
|
||||
out,
|
||||
"-- 未生成:前提/结论超出受限文法(check --proof 会给具体诊断)"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 命名空间:文件名的安全标识符(保留 unicode 字母;不安全字符 → `_`)。
|
||||
pub fn namespace_of(stem: &str) -> String {
|
||||
let mut out = String::new();
|
||||
for ch in stem.chars() {
|
||||
if ch.is_alphanumeric() || ch == '_' {
|
||||
out.push(ch);
|
||||
} else {
|
||||
out.push('_');
|
||||
}
|
||||
}
|
||||
if out.is_empty() {
|
||||
out.push('M');
|
||||
}
|
||||
if out.chars().next().is_some_and(|c| c.is_ascii_digit()) {
|
||||
out.insert(0, 'M');
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Lean 保留字与本模块保留名(含点/空格的用 `«…»`;关键字加前缀)。
|
||||
const LEAN_KEYWORDS: &[&str] = &[
|
||||
"fun", "let", "in", "do", "match", "with", "if", "then", "else", "true", "false", "and", "or",
|
||||
"not", "def", "theorem", "abbrev", "structure", "inductive", "where", "deriving", "open",
|
||||
"namespace", "end", "import", "by", "have", "show", "assume", "from", "at", "exists",
|
||||
];
|
||||
|
||||
fn lean_ident(name: &str) -> String {
|
||||
if LEAN_KEYWORDS.contains(&name) || name == "env" || name == "轨迹" || name == "结果" {
|
||||
format!("v_{name}")
|
||||
} else if name.chars().all(|c| c.is_alphanumeric() || c == '_' || c == '·')
|
||||
&& !name.chars().next().is_some_and(|c| c.is_ascii_digit())
|
||||
{
|
||||
name.to_string()
|
||||
} else {
|
||||
format!("«{name}»")
|
||||
}
|
||||
}
|
||||
|
||||
fn op_ctor(op_id: &str) -> String {
|
||||
// `调用:人工审核` → `«调用:人工审核»`(guillemet 标识符)。
|
||||
format!("«{op_id}»")
|
||||
}
|
||||
|
||||
fn emit_op_inductive(out: &mut String, plan: &Plan) {
|
||||
// 收集 op(首现顺序去重)。
|
||||
let mut ops: Vec<&crate::prove::ir::OpDecl> = Vec::new();
|
||||
for fun in &plan.functions {
|
||||
for op in &fun.ops {
|
||||
if !ops.iter().any(|o| o.id == op.id) {
|
||||
ops.push(op);
|
||||
}
|
||||
}
|
||||
}
|
||||
if ops.is_empty() {
|
||||
let _ = writeln!(out, "inductive Op where");
|
||||
let _ = writeln!(out, " | 无操作 deriving Repr, BEq");
|
||||
let _ = writeln!(out);
|
||||
let _ = writeln!(out, "def Op.name : Op → String");
|
||||
let _ = writeln!(out, " | .无操作 => \"\"");
|
||||
return;
|
||||
}
|
||||
let _ = writeln!(out, "inductive Op where");
|
||||
for op in &ops {
|
||||
let fields = match op.arity {
|
||||
0 => String::new(),
|
||||
n => (1..=n)
|
||||
.map(|i| format!("(参数{i} : Val)"))
|
||||
.collect::<Vec<_>>()
|
||||
.join(" "),
|
||||
};
|
||||
let _ = writeln!(out, " | {} {}", op_ctor(&op.id), fields);
|
||||
}
|
||||
let _ = writeln!(out, " deriving Repr, BEq");
|
||||
let _ = writeln!(out);
|
||||
let _ = writeln!(out, "def Op.name : Op → String");
|
||||
for op in &ops {
|
||||
let label = op.id.strip_prefix("调用:").unwrap_or(&op.id);
|
||||
let blanks = " ".repeat(op.arity);
|
||||
let _ = writeln!(out, " | .{} {}=> \"{}\"", op_ctor(&op.id), blanks, label);
|
||||
}
|
||||
}
|
||||
|
||||
fn emit_function(out: &mut String, fun: &FnPlan) {
|
||||
let name = lean_ident(&fun.name);
|
||||
// 参数列表:`def f (env : Env) (轨迹 : List Op) (p1 : Val) …`
|
||||
let mut sig = String::from("(env : Env) (轨迹 : List Op)");
|
||||
for param in &fun.params {
|
||||
let _ = write!(sig, " ({} : Val)", lean_ident(¶m.name));
|
||||
}
|
||||
let _ = writeln!(out, "-- {} 返回 {}", fun.name, fun.result_ty.name());
|
||||
let _ = writeln!(out, "def {name} {sig} : Val × List Op :=");
|
||||
if fun.steps.is_empty() {
|
||||
let _ = writeln!(out, " (Val.none, 轨迹)");
|
||||
return;
|
||||
}
|
||||
emit_seq(out, &mut String::from(" "), &[&fun.steps]);
|
||||
}
|
||||
|
||||
/// 续延式直接降级(§6.3):`chunks` 是"当前点之后还要执行的所有步骤"。
|
||||
///
|
||||
/// `if` 的两臂续延是「臂内步骤 + 臂外剩余」——执行继续到分支之后,
|
||||
/// 除非某臂已提前 `Return`。这是 P0 第一版的续延丢失 bug 的修正:
|
||||
/// 分支绝不能吞掉后续语句。
|
||||
fn emit_seq(out: &mut String, indent: &mut String, chunks: &[&[Step]]) {
|
||||
match chunks.split_first() {
|
||||
None => {
|
||||
// 走到末尾都没有 return:Marqdo 返回 None(诚实占位,不译运行时)。
|
||||
let _ = writeln!(out, "{indent}(Val.none, 轨迹)");
|
||||
}
|
||||
Some((first, rest)) => match first.split_first() {
|
||||
None => emit_seq(out, indent, rest),
|
||||
Some((step, more)) => emit_step(out, indent, step, more, rest),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn tail_chunks<'a>(more: &'a [Step], rest: &[&'a [Step]]) -> Vec<&'a [Step]> {
|
||||
let mut next: Vec<&'a [Step]> = Vec::with_capacity(rest.len() + 1);
|
||||
if !more.is_empty() {
|
||||
next.push(more);
|
||||
}
|
||||
next.extend_from_slice(rest);
|
||||
next
|
||||
}
|
||||
|
||||
fn emit_step(out: &mut String, indent: &mut String, step: &Step, more: &[Step], rest: &[&[Step]]) {
|
||||
match step {
|
||||
Step::Bind { var, expr, line } => {
|
||||
let _ = writeln!(out, "{indent}-- mq: {line}:1");
|
||||
match expr {
|
||||
IrExpr::Op { id, args } => {
|
||||
let _ = writeln!(
|
||||
out,
|
||||
"{indent}let {} := env (Op.{} {})",
|
||||
lean_ident(var),
|
||||
op_ctor(id),
|
||||
emit_args(args)
|
||||
);
|
||||
let _ = writeln!(
|
||||
out,
|
||||
"{indent}let 轨迹 := 轨迹 ++ [Op.{} {}]",
|
||||
op_ctor(id),
|
||||
emit_args(args)
|
||||
);
|
||||
}
|
||||
other => {
|
||||
let _ = writeln!(
|
||||
out,
|
||||
"{indent}let {} := {}",
|
||||
lean_ident(var),
|
||||
emit_expr(other)
|
||||
);
|
||||
}
|
||||
}
|
||||
emit_seq(out, indent, &tail_chunks(more, rest));
|
||||
}
|
||||
Step::Return { expr, line } => {
|
||||
let _ = writeln!(out, "{indent}-- mq: {line}:1");
|
||||
match expr {
|
||||
IrExpr::Op { id, args } => {
|
||||
let _ = writeln!(
|
||||
out,
|
||||
"{indent}(env (Op.{} {}), 轨迹 ++ [Op.{} {}])",
|
||||
op_ctor(id),
|
||||
emit_args(args),
|
||||
op_ctor(id),
|
||||
emit_args(args)
|
||||
);
|
||||
}
|
||||
other => {
|
||||
let _ = writeln!(out, "{indent}({}, 轨迹)", emit_expr(other));
|
||||
}
|
||||
}
|
||||
}
|
||||
Step::Trace { op, args, line } => {
|
||||
let _ = writeln!(out, "{indent}-- mq: {line}:1");
|
||||
let _ = writeln!(
|
||||
out,
|
||||
"{indent}let 轨迹 := 轨迹 ++ [Op.{} {}]",
|
||||
op_ctor(op),
|
||||
emit_args(args)
|
||||
);
|
||||
emit_seq(out, indent, &tail_chunks(more, rest));
|
||||
}
|
||||
Step::If {
|
||||
cond,
|
||||
then,
|
||||
otherwise,
|
||||
line,
|
||||
} => {
|
||||
let _ = writeln!(out, "{indent}-- mq: {line}:1");
|
||||
let _ = writeln!(out, "{indent}if {} then", emit_cond(cond));
|
||||
indent.push_str(" ");
|
||||
let then_chunks = {
|
||||
let mut v: Vec<&[Step]> = Vec::with_capacity(rest.len() + 1);
|
||||
v.push(then);
|
||||
v.extend_from_slice(&tail_chunks(more, rest));
|
||||
v
|
||||
};
|
||||
emit_seq(out, indent, &then_chunks);
|
||||
indent.truncate(indent.len() - 2);
|
||||
let _ = writeln!(out, "{indent}else");
|
||||
indent.push_str(" ");
|
||||
let else_chunks = {
|
||||
let mut v: Vec<&[Step]> = Vec::with_capacity(rest.len() + 1);
|
||||
v.push(otherwise);
|
||||
v.extend_from_slice(&tail_chunks(more, rest));
|
||||
v
|
||||
};
|
||||
emit_seq(out, indent, &else_chunks);
|
||||
indent.truncate(indent.len() - 2);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 条件:比较直接产出 Bool;其余经 `mqTruth`(Val → Bool)。
|
||||
fn emit_cond(cond: &PureExpr) -> String {
|
||||
match cond {
|
||||
PureExpr::Bin {
|
||||
operator: BinOp::Eq | BinOp::Ne | BinOp::Lt | BinOp::Le | BinOp::Gt | BinOp::Ge,
|
||||
..
|
||||
} => emit_pure(cond),
|
||||
_ => format!("mqTruth ({})", emit_pure(cond)),
|
||||
}
|
||||
}
|
||||
|
||||
fn emit_args(args: &[PureExpr]) -> String {
|
||||
args.iter()
|
||||
.map(|a| emit_pure(a))
|
||||
.collect::<Vec<_>>()
|
||||
.join(" ")
|
||||
}
|
||||
|
||||
fn emit_expr(expr: &IrExpr) -> String {
|
||||
match expr {
|
||||
IrExpr::Pure(pure) => emit_pure(pure),
|
||||
// 语句层不会遇到(Op 已在 Bind/Return/Trace 处理);防御性回退。
|
||||
IrExpr::Op { id, args } => {
|
||||
format!("env (Op.{} {})", op_ctor(id), emit_args(args))
|
||||
}
|
||||
IrExpr::Formula => "Val.none -- $$公式$$:不透明值".into(),
|
||||
IrExpr::Code => "Val.none -- code 围栏:不透明值".into(),
|
||||
}
|
||||
}
|
||||
|
||||
fn emit_pure(pure: &PureExpr) -> String {
|
||||
match pure {
|
||||
PureExpr::Int(i) => format!("(Val.int {i})"),
|
||||
PureExpr::Num(n) => format!("(Val.num {n:?})"),
|
||||
PureExpr::Bool(b) => format!("(Val.bool {})", if *b { "true" } else { "false" }),
|
||||
PureExpr::Text(s) => format!("(Val.text {})", lean_string(s)),
|
||||
PureExpr::None => "Val.none".into(),
|
||||
PureExpr::Var(name) => lean_ident(name),
|
||||
PureExpr::Bin { operator, left, right } => {
|
||||
let (l, r) = (emit_pure(left), emit_pure(right));
|
||||
match operator {
|
||||
BinOp::Add => format!("(mqAdd {l} {r})"),
|
||||
BinOp::Sub => format!("(mqSub {l} {r})"),
|
||||
BinOp::Mul => format!("(mqMul {l} {r})"),
|
||||
BinOp::Div => format!("(mqDiv {l} {r})"),
|
||||
BinOp::Eq => format!("(mqEq {l} {r})"),
|
||||
BinOp::Ne => format!("(mqNot (mqEq {l} {r}))"),
|
||||
BinOp::Lt => format!("(mqLt {l} {r})"),
|
||||
BinOp::Le => format!("(mqLe {l} {r})"),
|
||||
BinOp::Gt => format!("(mqGt {l} {r})"),
|
||||
BinOp::Ge => format!("(mqGe {l} {r})"),
|
||||
BinOp::And => format!("(mqAnd {l} {r})"),
|
||||
BinOp::Or => format!("(mqOr {l} {r})"),
|
||||
}
|
||||
}
|
||||
PureExpr::Un { operator, expr } => {
|
||||
let e = emit_pure(expr);
|
||||
match operator {
|
||||
UnOp::Not => format!("(mqNot {e})"),
|
||||
UnOp::Neg => format!("(mqNeg {e})"),
|
||||
}
|
||||
}
|
||||
PureExpr::Index { base, key } => {
|
||||
format!("(mqAccess {} {})", emit_pure(base), lean_string(key))
|
||||
}
|
||||
PureExpr::Access { base, key } => {
|
||||
format!("(mqAccess {} {})", emit_pure(base), lean_string(key))
|
||||
}
|
||||
PureExpr::Len(inner) => format!("(mqLen {})", emit_pure(inner)),
|
||||
PureExpr::Interp(parts) => emit_interp(parts),
|
||||
PureExpr::List(items) => {
|
||||
let inner: Vec<String> = items.iter().map(emit_pure).collect();
|
||||
format!("(Val.list [{}])", inner.join(", "))
|
||||
}
|
||||
PureExpr::Map(entries) => {
|
||||
let inner: Vec<String> = entries
|
||||
.iter()
|
||||
.map(|(k, v)| format!("({}, {})", lean_string(k), emit_pure(v)))
|
||||
.collect();
|
||||
format!("(Val.map [{}])", inner.join(", "))
|
||||
}
|
||||
PureExpr::Ctor { name, args } => emit_ctor(name, args),
|
||||
}
|
||||
}
|
||||
|
||||
/// 内联构造器:`result.ok/error/value_or` 映射到库辅助函数
|
||||
/// (Val 字面 map,与 lib/result 行为一致);`mq.*` 直呼。
|
||||
fn emit_ctor(name: &str, args: &[PureExpr]) -> String {
|
||||
let rendered: Vec<String> = args.iter().map(emit_pure).collect();
|
||||
match (name, rendered.as_slice()) {
|
||||
("result.ok", [value]) => format!("(mqResultOk {value})"),
|
||||
("result.error", [code, message, operation]) => {
|
||||
format!("(mqResultError {code} {message} {operation})")
|
||||
}
|
||||
("result.value_or", [r, default]) => format!("(mqValueOr {r} {default})"),
|
||||
_ => format!("({} {})", name.replace('.', "_"), rendered.join(" ")),
|
||||
}
|
||||
}
|
||||
|
||||
fn emit_interp(parts: &[InterpPart]) -> String {
|
||||
let mut pieces: Vec<String> = Vec::new();
|
||||
for part in parts {
|
||||
match part {
|
||||
InterpPart::Lit(text) => pieces.push(format!("(Val.text {})", lean_string(text))),
|
||||
InterpPart::Var(name) => pieces.push(lean_ident(name)),
|
||||
}
|
||||
}
|
||||
if pieces.is_empty() {
|
||||
return "(Val.text \"\")".into();
|
||||
}
|
||||
let mut it = pieces.into_iter();
|
||||
let first = it.next().unwrap();
|
||||
it.fold(first, |acc, piece| format!("(mqAppend {acc} {piece})"))
|
||||
}
|
||||
|
||||
/// Lean 字符串字面量(转义 `\` `"` 与控制字符;非 ASCII 原样保留)。
|
||||
fn lean_string(s: &str) -> String {
|
||||
let mut out = String::with_capacity(s.len() + 2);
|
||||
out.push('"');
|
||||
for ch in s.chars() {
|
||||
match ch {
|
||||
'"' => out.push_str("\\\""),
|
||||
'\\' => out.push_str("\\\\"),
|
||||
'\n' => out.push_str("\\n"),
|
||||
'\t' => out.push_str("\\t"),
|
||||
'\r' => out.push_str("\\r"),
|
||||
c => out.push(c),
|
||||
}
|
||||
}
|
||||
out.push('"');
|
||||
out
|
||||
}
|
||||
|
||||
/// 模块 stem(命名空间用):去扩展名的文件名。
|
||||
pub fn stem_of(path: &str) -> String {
|
||||
std::path::Path::new(path)
|
||||
.file_stem()
|
||||
.map(|s| s.to_string_lossy().to_string())
|
||||
.unwrap_or_else(|| "Module".into())
|
||||
}
|
||||
|
||||
/// PlanTy 的 Lean 侧提示注释(P1 提升类型用;P0 参数统一 Val)。
|
||||
pub fn ty_hint(ty: &PlanTy) -> &'static str {
|
||||
match ty {
|
||||
PlanTy::Int => "Int",
|
||||
PlanTy::Num => "Float",
|
||||
PlanTy::Bool => "Bool",
|
||||
PlanTy::Text => "String",
|
||||
_ => "Val",
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::prove::ir::{Expr, FnPlan, OpDecl, PlanTy, Step};
|
||||
|
||||
#[test]
|
||||
fn lean_ident_keeps_chinese_and_quotes_dotted() {
|
||||
assert_eq!(lean_ident("金额"), "金额");
|
||||
assert_eq!(lean_ident("审批台.审批"), "«审批台.审批»");
|
||||
// 与本模块保留名冲突的变量必须改名(确定性映射)。
|
||||
assert_eq!(lean_ident("env"), "v_env");
|
||||
assert_eq!(lean_ident("轨迹"), "v_轨迹");
|
||||
assert_eq!(lean_ident("结果"), "v_结果");
|
||||
assert_eq!(lean_ident("let"), "v_let");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lean_string_escapes_quotes_and_newline_only() {
|
||||
assert_eq!(lean_string("a\"b\\c"), "\"a\\\"b\\\\c\"");
|
||||
assert_eq!(lean_string("行\n进"), "\"行\\n进\"");
|
||||
assert_eq!(lean_string("中文"), "\"中文\"");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn namespace_sanitizes_unsafe_chars_deterministically() {
|
||||
assert_eq!(namespace_of("approval.mq"), "approval_mq");
|
||||
assert_eq!(namespace_of("示例"), "示例");
|
||||
assert_eq!(namespace_of("1abc"), "M1abc");
|
||||
assert_eq!(namespace_of(""), "M");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn emit_module_is_deterministic_and_sorted_by_first_appearance() {
|
||||
let plan = Plan {
|
||||
schema: crate::prove::ir::SCHEMA,
|
||||
module: "demo.mq.md".into(),
|
||||
source_sha256: "ab".repeat(32),
|
||||
functions: vec![
|
||||
FnPlan {
|
||||
name: "机器.运转".into(),
|
||||
params: vec![],
|
||||
result_ty: PlanTy::Any,
|
||||
ops: vec![
|
||||
OpDecl {
|
||||
id: "调用:写盘".into(),
|
||||
effect: "fs.write".into(),
|
||||
params: vec![],
|
||||
arity: 1,
|
||||
},
|
||||
OpDecl {
|
||||
id: "调用:读盘".into(),
|
||||
effect: "fs.read".into(),
|
||||
params: vec![],
|
||||
arity: 0,
|
||||
},
|
||||
],
|
||||
steps: vec![Step::Bind {
|
||||
var: "回执".into(),
|
||||
expr: Expr::Op {
|
||||
id: "调用:写盘".into(),
|
||||
args: vec![],
|
||||
},
|
||||
line: 3,
|
||||
}],
|
||||
effects: vec!["fs.write".into()],
|
||||
claims: vec![],
|
||||
assumptions: vec![],
|
||||
},
|
||||
FnPlan {
|
||||
name: "从机.待机".into(),
|
||||
params: vec![],
|
||||
result_ty: PlanTy::Any,
|
||||
ops: vec![],
|
||||
steps: vec![Step::Return {
|
||||
expr: Expr::Pure(PureExpr::Int(7)),
|
||||
line: 9,
|
||||
}],
|
||||
effects: vec![],
|
||||
claims: vec![],
|
||||
assumptions: vec![],
|
||||
},
|
||||
],
|
||||
};
|
||||
let (name1, out1) = emit_module(&plan, "demo");
|
||||
let (name2, out2) = emit_module(&plan, "demo");
|
||||
assert_eq!(name1, name2);
|
||||
assert_eq!(out1, out2, "两次生成必须字节一致");
|
||||
assert!(out1.contains("import MarqdoProof"));
|
||||
assert!(out1.contains("namespace Generated.demo"));
|
||||
// Op 按首现顺序:写盘在读盘前。
|
||||
let write_pos = out1.find("«调用:写盘»").expect("write op");
|
||||
let read_pos = out1.find("«调用:读盘»").expect("read op");
|
||||
assert!(write_pos < read_pos);
|
||||
// Op 元数:读盘 0 元 → 无参构造器。
|
||||
assert!(out1.contains("| «调用:读盘»"), "{out1}");
|
||||
// Return 直译成对(字面量自带括号,形成双重括号——合法 Lean)。
|
||||
assert!(out1.contains("((Val.int 7), 轨迹)"), "{out1}");
|
||||
// 溯源注释。
|
||||
assert!(out1.contains("-- mq: 3:1"));
|
||||
// 无时间戳。
|
||||
assert!(!out1.contains("20") || !out1.contains("T"), "no timestamps");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn empty_plan_emits_no_op_ctors() {
|
||||
let plan = Plan {
|
||||
schema: crate::prove::ir::SCHEMA,
|
||||
module: "空.mq.md".into(),
|
||||
source_sha256: "cd".repeat(32),
|
||||
functions: vec![],
|
||||
};
|
||||
let (name, out) = emit_module(&plan, "空");
|
||||
assert_eq!(name, "空.lean");
|
||||
assert!(out.contains("| 无操作"));
|
||||
assert!(!out.contains("«调用:"));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/// 受限命题文本 → Lean Bool 项;解析失败或含未知形状 → None(emit 侧留注释)。
|
||||
/// 语义映射(§7.2):
|
||||
/// - `结果.ok / 结果.value / 结果.error` → `mqAccess 结果 "ok"` 等;
|
||||
/// - `包含(轨迹, s)` → `(轨迹.map Op.name).contains s`;
|
||||
/// - `长度(轨迹)` → `(轨迹.length : Nat)`(与自然数比较);
|
||||
/// - 形参/算术/比较 → mq 辅助函数(Val 面)。
|
||||
fn claim_to_lean_bool(text: &str) -> Option<String> {
|
||||
let toks = super::proof_check::tokenize_claim(text).ok()?;
|
||||
let (_, ast) = super::proof_check::parse_claim_expr(&toks).ok()?;
|
||||
Some(claim_term(&ast))
|
||||
}
|
||||
|
||||
fn claim_term(ast: &super::proof_check::ClaimAst) -> String {
|
||||
use super::proof_check::{ClaimAst as A, CTok};
|
||||
match ast {
|
||||
A::Lit(CTok::Int(i)) => format!("(Val.int {i})"),
|
||||
A::Lit(CTok::Num(n)) => format!("(Val.num {n:?})"),
|
||||
A::Lit(CTok::Bool(b)) => format!("(Val.bool {b})"),
|
||||
A::Lit(CTok::Text(s)) => format!("(Val.text {})", lean_string(s)),
|
||||
A::Lit(other) => format!("-- 未知字面量 {other:?}"),
|
||||
A::Var(name) => {
|
||||
// 定理作用域里 `结果`/`轨迹` 是 ∀ 绑定的输出名(不加 v_ 前缀);
|
||||
// `根.字段` → mqAccess 字段读取;其余按标识符规则(形参等)。
|
||||
let (root, field) = match name.split_once('.') {
|
||||
Some((r, f)) => (r, Some(f)),
|
||||
None => (name.as_str(), None),
|
||||
};
|
||||
match (root, field) {
|
||||
("结果", Some(f)) => format!("(mqAccess 结果 {})", lean_string(f)),
|
||||
("轨迹", Some(f)) => format!("(mqAccess 轨迹 {})", lean_string(f)),
|
||||
("结果", None) => "结果".to_string(),
|
||||
("轨迹", None) => "轨迹".to_string(),
|
||||
_ => lean_ident(name),
|
||||
}
|
||||
}
|
||||
A::Call { name, args } => {
|
||||
// `轨迹`(定理作用域的输出轨迹)上的谓词有专用 Lean 形式。
|
||||
let on_trace = matches!(args.first(), Some(A::Var(v)) if v == "轨迹");
|
||||
match (name.as_str(), args.len(), on_trace) {
|
||||
("包含", 2, true) => {
|
||||
format!(
|
||||
"((轨迹.map Op.name).contains {})",
|
||||
strip_val_text(&claim_term(&args[1]))
|
||||
)
|
||||
}
|
||||
("长度", 1, true) => "(轨迹.length : Nat)".to_string(),
|
||||
_ => {
|
||||
let rendered: Vec<String> = args.iter().map(claim_term).collect();
|
||||
match (name.as_str(), rendered.as_slice()) {
|
||||
("包含", [list, item]) => format!("(mqContains {list} {item})"),
|
||||
("长度", [list]) => format!("(mqNatOf (mqLen {list}))"),
|
||||
("下标", [list, index]) => {
|
||||
format!("(mqAccess {list} (mqStrOfNat {index}))")
|
||||
}
|
||||
_ => format!("({} {})", name, rendered.join(" ")),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
A::Bin { op, left, right } => {
|
||||
let (l, r) = (claim_term(left), claim_term(right));
|
||||
match *op {
|
||||
"+" => format!("(mqAdd {l} {r})"),
|
||||
"-" => format!("(mqSub {l} {r})"),
|
||||
"*" => format!("(mqMul {l} {r})"),
|
||||
"/" => format!("(mqDiv {l} {r})"),
|
||||
"=" => format!("(mqEq {l} {r})"),
|
||||
"≠" => format!("(mqNot (mqEq {l} {r}))"),
|
||||
"<" => format!("(mqLt {l} {r})"),
|
||||
"≤" => format!("(mqLe {l} {r})"),
|
||||
">" => format!("(mqGt {l} {r})"),
|
||||
"≥" => format!("(mqGe {l} {r})"),
|
||||
"且" => format!("(mqAnd {l} {r})"),
|
||||
"或" => format!("(mqOr {l} {r})"),
|
||||
other => format!("-- 未知算子 {other}"),
|
||||
}
|
||||
}
|
||||
A::Un { op, expr } => {
|
||||
let e = claim_term(expr);
|
||||
match *op {
|
||||
"非" => format!("(mqNot {e})"),
|
||||
"-" => format!("(mqNeg {e})"),
|
||||
other => format!("-- 未知一元算子 {other}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// `包含` 的成员是文本字面量时剥掉 Val 包裹(`(Val.text "x")` → `"x"`)。
|
||||
fn strip_val_text(term: &str) -> String {
|
||||
term.strip_prefix("(Val.text ")
|
||||
.and_then(|rest| rest.strip_suffix(')'))
|
||||
.map(|s| s.to_string())
|
||||
.unwrap_or_else(|| term.to_string())
|
||||
}
|
||||
+296
@@ -0,0 +1,296 @@
|
||||
//! Plan IR(`doc/design/prove-cli.md` §4.2)。
|
||||
//!
|
||||
//! `plan.json` 的形状:版本化、可序列化、无时间戳。缓存键与论文工具都以
|
||||
//! 它为输入。表达式分两层:[`PureExpr`] 是可翻译成 Lean 项的纯片段;
|
||||
//! 其余调用一律是不透明操作([`Step::Trace`] 引用 [`FnPlan::ops`])。
|
||||
|
||||
use serde::Serialize;
|
||||
|
||||
/// IR schema version(缓存失效用;形状变化必须 +1)。
|
||||
pub const SCHEMA: u32 = 1;
|
||||
|
||||
/// 契约类型在 Plan IR 里的形状(`contract::Ty` 的可序列化投影)。
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
|
||||
#[serde(tag = "kind", rename_all = "snake_case")]
|
||||
pub enum PlanTy {
|
||||
Int,
|
||||
Num,
|
||||
Bool,
|
||||
Text,
|
||||
List,
|
||||
Map,
|
||||
/// 内联 `Result` 构造器(`lib/result`):`ok/value/error` 三字段结构。
|
||||
Result,
|
||||
/// 未知/任意(`--no-strict-types` 或未标注)。定理只能做等式判断。
|
||||
Any,
|
||||
/// `# 对象` 类型实例。
|
||||
Object(String),
|
||||
}
|
||||
|
||||
impl PlanTy {
|
||||
pub fn name(&self) -> String {
|
||||
match self {
|
||||
PlanTy::Int => "int".into(),
|
||||
PlanTy::Num => "num".into(),
|
||||
PlanTy::Bool => "bool".into(),
|
||||
PlanTy::Text => "text".into(),
|
||||
PlanTy::List => "list".into(),
|
||||
PlanTy::Map => "map".into(),
|
||||
PlanTy::Result => "result".into(),
|
||||
PlanTy::Any => "any".into(),
|
||||
PlanTy::Object(n) => n.clone(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn from_contract(ty: &crate::contract::Ty) -> PlanTy {
|
||||
match ty {
|
||||
crate::contract::Ty::Any => PlanTy::Any,
|
||||
crate::contract::Ty::Text => PlanTy::Text,
|
||||
crate::contract::Ty::Number => PlanTy::Int,
|
||||
crate::contract::Ty::Bool => PlanTy::Bool,
|
||||
crate::contract::Ty::List => PlanTy::List,
|
||||
crate::contract::Ty::Map => PlanTy::Map,
|
||||
crate::contract::Ty::Object(n) => PlanTy::Object(n.clone()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 二元运算(纯片段内的算术/比较/布尔)。
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub enum BinOp {
|
||||
Add,
|
||||
Sub,
|
||||
Mul,
|
||||
Div,
|
||||
Eq,
|
||||
Ne,
|
||||
Lt,
|
||||
Le,
|
||||
Gt,
|
||||
Ge,
|
||||
And,
|
||||
Or,
|
||||
}
|
||||
|
||||
impl BinOp {
|
||||
pub fn from_ast(op: crate::ast::BinaryOp) -> BinOp {
|
||||
use crate::ast::BinaryOp as A;
|
||||
match op {
|
||||
A::Add => BinOp::Add,
|
||||
A::Sub => BinOp::Sub,
|
||||
A::Mul => BinOp::Mul,
|
||||
A::Div => BinOp::Div,
|
||||
A::Eq => BinOp::Eq,
|
||||
A::Ne => BinOp::Ne,
|
||||
A::Lt => BinOp::Lt,
|
||||
A::Le => BinOp::Le,
|
||||
A::Gt => BinOp::Gt,
|
||||
A::Ge => BinOp::Ge,
|
||||
A::And => BinOp::And,
|
||||
A::Or => BinOp::Or,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 一元运算。
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub enum UnOp {
|
||||
Not,
|
||||
Neg,
|
||||
}
|
||||
|
||||
/// 纯表达式:可翻译成 Lean 项的部分(§4.2 表达式分层)。
|
||||
/// 相邻标记(`kind` + `value`):新类型变体也能稳定序列化。
|
||||
#[derive(Debug, Clone, PartialEq, Serialize)]
|
||||
#[serde(tag = "kind", content = "value", rename_all = "snake_case")]
|
||||
pub enum PureExpr {
|
||||
Int(i64),
|
||||
Num(f64),
|
||||
Bool(bool),
|
||||
Text(String),
|
||||
None,
|
||||
Var(String),
|
||||
Bin {
|
||||
operator: BinOp,
|
||||
left: Box<PureExpr>,
|
||||
right: Box<PureExpr>,
|
||||
},
|
||||
Un {
|
||||
operator: UnOp,
|
||||
expr: Box<PureExpr>,
|
||||
},
|
||||
/// 映射字段/下标读取:`` [键](映射) `` / `` `m`[^键] ``。
|
||||
Index {
|
||||
base: Box<PureExpr>,
|
||||
key: String,
|
||||
},
|
||||
/// `access(base, key)`(含 `取`/`取值` 别名)。
|
||||
Access {
|
||||
base: Box<PureExpr>,
|
||||
key: String,
|
||||
},
|
||||
/// `len(value)`(含 `长度` 别名)。
|
||||
Len(Box<PureExpr>),
|
||||
/// 文本插值拼接(`` "共 `n` 条" `` → append 序列)。
|
||||
Interp(Vec<InterpPart>),
|
||||
List(Vec<PureExpr>),
|
||||
Map(Vec<(String, PureExpr)>),
|
||||
/// 已内联的构造器调用(`result.success/failure`)。
|
||||
Ctor {
|
||||
name: String,
|
||||
args: Vec<PureExpr>,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Serialize)]
|
||||
#[serde(tag = "part", content = "value", rename_all = "snake_case")]
|
||||
pub enum InterpPart {
|
||||
Lit(String),
|
||||
Var(String),
|
||||
}
|
||||
|
||||
/// 语句(§4.3 接受矩阵的接受侧)。
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
#[serde(tag = "kind", rename_all = "snake_case")]
|
||||
pub enum Step {
|
||||
/// `**x = 表达式**`
|
||||
Bind {
|
||||
var: String,
|
||||
expr: Expr,
|
||||
line: u32,
|
||||
},
|
||||
/// `**返回表达式**`(粗体无赋值)
|
||||
Return {
|
||||
expr: Expr,
|
||||
line: u32,
|
||||
},
|
||||
/// `1. 条件 / 2. *`(else 由 `cond: None` 表示)
|
||||
If {
|
||||
cond: PureExpr,
|
||||
then: Vec<Step>,
|
||||
otherwise: Vec<Step>,
|
||||
line: u32,
|
||||
},
|
||||
/// 语句形式调用(`> 调用` / `*语句*`):值丢弃,但仍进轨迹。
|
||||
Trace {
|
||||
op: String,
|
||||
args: Vec<PureExpr>,
|
||||
line: u32,
|
||||
},
|
||||
}
|
||||
|
||||
/// 语句内表达式:纯表达式或不透明操作调用。
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
#[serde(tag = "kind", rename_all = "snake_case")]
|
||||
pub enum Expr {
|
||||
Pure(PureExpr),
|
||||
/// 不透明操作调用:`ops` 里的 `id`(接收者/插件/有效应的调用)。
|
||||
Op {
|
||||
id: String,
|
||||
args: Vec<PureExpr>,
|
||||
},
|
||||
/// `$$…$$` 公式:不透明值,不翻译。
|
||||
Formula,
|
||||
/// ``` 围栏 code 值(不经 parse 拒绝时降为不透明)。
|
||||
Code,
|
||||
}
|
||||
|
||||
/// 一个不透明操作的声明(Lean 里是 `Op` 构造器 + `Env` 查询键)。
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
pub struct OpDecl {
|
||||
pub id: String,
|
||||
pub effect: String,
|
||||
pub params: Vec<(String, PlanTy)>,
|
||||
/// 实参个数(首次出现处;同名操作元数一致)。
|
||||
pub arity: usize,
|
||||
}
|
||||
|
||||
/// 定理占位(P1 起填充;P0 恒为空,保持 `plan.json` 形状稳定)。
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
pub struct ClaimPlan {
|
||||
pub id: String,
|
||||
pub premise: Option<String>,
|
||||
pub conclusion: String,
|
||||
pub tactic: Option<String>,
|
||||
/// 定理表行号(锚定源码漂移)。
|
||||
pub line: u32,
|
||||
}
|
||||
|
||||
/// 假设表条目(T3;P0 恒为空)。
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
pub struct AssumptionPlan {
|
||||
pub op: String,
|
||||
pub premise: Option<String>,
|
||||
pub postcondition: String,
|
||||
}
|
||||
|
||||
/// 单个函数的 Plan。
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
pub struct FnPlan {
|
||||
pub name: String,
|
||||
pub params: Vec<ParamPlan>,
|
||||
pub result_ty: PlanTy,
|
||||
/// 该函数用到的不透明操作(按出现顺序,去重)。
|
||||
pub ops: Vec<OpDecl>,
|
||||
pub steps: Vec<Step>,
|
||||
pub effects: Vec<String>,
|
||||
pub claims: Vec<ClaimPlan>,
|
||||
pub assumptions: Vec<AssumptionPlan>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
pub struct ParamPlan {
|
||||
pub name: String,
|
||||
pub ty: PlanTy,
|
||||
pub has_default: bool,
|
||||
}
|
||||
|
||||
/// 整个文件的 Plan。
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
pub struct Plan {
|
||||
pub schema: u32,
|
||||
/// 相对当前工作目录的路径(确定性要求:无绝对路径、无时间戳)。
|
||||
pub module: String,
|
||||
pub source_sha256: String,
|
||||
pub functions: Vec<FnPlan>,
|
||||
}
|
||||
|
||||
impl Plan {
|
||||
/// 规范化 JSON(键序稳定、无空白差异;两次运行必须字节一致)。
|
||||
pub fn to_stable_json(&self) -> String {
|
||||
let value = serde_json::to_value(self).expect("plan serializes");
|
||||
format_value(&value)
|
||||
}
|
||||
}
|
||||
|
||||
/// 确定性 JSON 序列化:对象键排序、数组保序、定长浮点。
|
||||
fn format_value(value: &serde_json::Value) -> String {
|
||||
use serde_json::Value;
|
||||
match value {
|
||||
Value::Null => "null".into(),
|
||||
Value::Bool(b) => b.to_string(),
|
||||
Value::Number(n) => n.to_string(),
|
||||
Value::String(s) => serde_json::to_string(s).expect("string serializes"),
|
||||
Value::Array(items) => {
|
||||
let inner: Vec<String> = items.iter().map(format_value).collect();
|
||||
format!("[{}]", inner.join(","))
|
||||
}
|
||||
Value::Object(map) => {
|
||||
let mut keys: Vec<&String> = map.keys().collect();
|
||||
keys.sort();
|
||||
let inner: Vec<String> = keys
|
||||
.into_iter()
|
||||
.map(|k| {
|
||||
format!(
|
||||
"{}:{}",
|
||||
serde_json::to_string(k).expect("key serializes"),
|
||||
format_value(&map[k])
|
||||
)
|
||||
})
|
||||
.collect();
|
||||
format!("{{{}}}", inner.join(","))
|
||||
}
|
||||
}
|
||||
}
|
||||
+1241
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,382 @@
|
||||
//! `marqdo prove`:SKILL 控制平面 → Lean 4(`doc/design/prove-cli.md`)。
|
||||
//!
|
||||
//! 三条契约(设计 §1.3):
|
||||
//! 1. **诚实**——只报实际做过的判定;`checked` 永不冒充 Lean 结论;
|
||||
//! 2. **单调**——离线判定严格弱于 Lean(P2 落地护栏);
|
||||
//! 3. **不执行**——本模块只读源码,从不运行目标程序。
|
||||
//!
|
||||
//! P0 范围(roadmap/prove.md §2):装载 → 降级 → 定型 → 确定性生成 + audit。
|
||||
//! 判定(离线 ⑤ / Lean ⑥)在 P1/P2 接入;状态只到 `unverified` / `rejected` /
|
||||
//! `error`。
|
||||
|
||||
pub mod emit;
|
||||
pub mod ir;
|
||||
pub mod lower;
|
||||
pub mod proof_check;
|
||||
pub mod types;
|
||||
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::time::Instant;
|
||||
|
||||
use anyhow::{Context, Result};
|
||||
|
||||
use crate::diagnostics::Diagnostic;
|
||||
use crate::prove::lower::Lowered;
|
||||
|
||||
/// 判定层级(P0 恒 `none`)。
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum Tier {
|
||||
Lean,
|
||||
Offline,
|
||||
None,
|
||||
}
|
||||
|
||||
impl Tier {
|
||||
pub fn as_str(self) -> &'static str {
|
||||
match self {
|
||||
Tier::Lean => "lean",
|
||||
Tier::Offline => "offline",
|
||||
Tier::None => "none",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 状态词(§1.2;P0 只会产生 `unverified` / `rejected` / `error`)。
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum Verdict {
|
||||
Proved,
|
||||
Checked,
|
||||
Unverified,
|
||||
Unproved,
|
||||
Rejected,
|
||||
Error,
|
||||
}
|
||||
|
||||
impl Verdict {
|
||||
pub fn as_str(self) -> &'static str {
|
||||
match self {
|
||||
Verdict::Proved => "proved",
|
||||
Verdict::Checked => "checked",
|
||||
Verdict::Unverified => "unverified",
|
||||
Verdict::Unproved => "unproved",
|
||||
Verdict::Rejected => "rejected",
|
||||
Verdict::Error => "error",
|
||||
}
|
||||
}
|
||||
|
||||
/// 聚合优先级(差者胜):error > unproved > rejected > unverified > checked > proved。
|
||||
pub fn rank(self) -> u8 {
|
||||
match self {
|
||||
Verdict::Proved => 0,
|
||||
Verdict::Checked => 1,
|
||||
Verdict::Unverified => 2,
|
||||
Verdict::Rejected => 3,
|
||||
Verdict::Unproved => 4,
|
||||
Verdict::Error => 5,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn worst(a: Verdict, b: Verdict) -> Verdict {
|
||||
if a.rank() >= b.rank() {
|
||||
a
|
||||
} else {
|
||||
b
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 退出码(§3.3)。
|
||||
impl Verdict {
|
||||
pub fn exit_code(self, require_lean: bool) -> i32 {
|
||||
match self {
|
||||
Verdict::Error => 1,
|
||||
Verdict::Unproved => 1,
|
||||
Verdict::Rejected | Verdict::Unverified | Verdict::Checked if require_lean => 2,
|
||||
_ => 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 选项(§8.2;P0 生效的子集见字段注释)。
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct ProveOptions {
|
||||
pub entry: Option<String>,
|
||||
pub only: Vec<String>,
|
||||
pub allow_opaque: Vec<String>,
|
||||
pub emit_dir: Option<PathBuf>,
|
||||
pub strict_types: bool,
|
||||
pub require_lean: bool,
|
||||
pub report_only: bool,
|
||||
}
|
||||
|
||||
impl Default for ProveOptions {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
entry: None,
|
||||
only: Vec::new(),
|
||||
allow_opaque: Vec::new(),
|
||||
emit_dir: None,
|
||||
strict_types: true,
|
||||
require_lean: false,
|
||||
report_only: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 单函数报告。
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct FunctionReport {
|
||||
pub name: String,
|
||||
pub verdict: Verdict,
|
||||
pub tier: Tier,
|
||||
/// 不透明操作(id, effect)。
|
||||
pub ops: Vec<(String, String)>,
|
||||
/// 拒绝原因(code, message, line)。
|
||||
pub rejected: Vec<(String, String, u32)>,
|
||||
/// 定理声明(id, premise, conclusion, tactic)。
|
||||
pub claims: Vec<(String, Option<String>, String, Option<String>)>,
|
||||
}
|
||||
|
||||
/// 整体报告。
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Report {
|
||||
pub file: String,
|
||||
pub source_sha256: String,
|
||||
pub status: Verdict,
|
||||
pub functions: Vec<FunctionReport>,
|
||||
pub diagnostics: Vec<Diagnostic>,
|
||||
pub emitted: Vec<PathBuf>,
|
||||
pub duration_ms: u128,
|
||||
}
|
||||
|
||||
impl Report {
|
||||
/// JSON 面(§3.5;`status` 枚举稳定,`lean` 恒 null 直到 P1)。
|
||||
pub fn to_json(&self) -> serde_json::Value {
|
||||
use serde_json::json;
|
||||
json!({
|
||||
"schema": 1,
|
||||
"status": self.status.as_str(),
|
||||
"file": self.file,
|
||||
"source_sha256": self.source_sha256,
|
||||
"artifact_id": serde_json::Value::Null,
|
||||
"functions": self.functions.iter().map(|f| json!({
|
||||
"name": f.name,
|
||||
"status": f.verdict.as_str(),
|
||||
"tier": f.tier.as_str(),
|
||||
"claims": f.claims.iter().map(|(id, premise, conclusion, tactic)| json!({
|
||||
"id": id,
|
||||
"premise": premise,
|
||||
"conclusion": conclusion,
|
||||
"tactic": tactic,
|
||||
})).collect::<Vec<_>>(),
|
||||
"obligations": [],
|
||||
"ops": f.ops.iter().map(|(id, effect)| json!({
|
||||
"id": id, "effect": effect,
|
||||
})).collect::<Vec<_>>(),
|
||||
"rejected": f.rejected.iter().map(|(code, message, line)| json!({
|
||||
"code": code, "message": message, "line": line,
|
||||
})).collect::<Vec<_>>(),
|
||||
})).collect::<Vec<_>>(),
|
||||
"lean": serde_json::Value::Null,
|
||||
"assumptions": [],
|
||||
"diagnostics": self.diagnostics.iter().map(|d| d.to_json()).collect::<Vec<_>>(),
|
||||
"emitted": self.emitted.iter().map(|p| p.display().to_string()).collect::<Vec<_>>(),
|
||||
"duration_ms": self.duration_ms as u64,
|
||||
})
|
||||
}
|
||||
|
||||
/// 文本面(§3.4 风格;诊断走 stderr 由 main 负责)。
|
||||
pub fn to_text(&self) -> String {
|
||||
let mut out = String::new();
|
||||
let functions = self.functions.len();
|
||||
let rejected = self
|
||||
.functions
|
||||
.iter()
|
||||
.filter(|f| f.verdict == Verdict::Rejected)
|
||||
.count();
|
||||
let ops: usize = self.functions.iter().map(|f| f.ops.len()).sum();
|
||||
out.push_str(&format!("prove: {}\n", self.file));
|
||||
out.push_str(&format!(
|
||||
" status: {}{}\n",
|
||||
self.status.as_str(),
|
||||
if self.status == Verdict::Unverified {
|
||||
"(P0:仅降级与生成,判定将在 P1 提供)"
|
||||
} else {
|
||||
""
|
||||
}
|
||||
));
|
||||
out.push_str(&format!(
|
||||
" functions: {functions} · opaque ops: {ops} · rejected: {rejected}\n"
|
||||
));
|
||||
for f in &self.functions {
|
||||
if f.verdict == Verdict::Rejected {
|
||||
let codes: Vec<&str> = f.rejected.iter().map(|(c, _, _)| c.as_str()).collect();
|
||||
out.push_str(&format!(" rejected: {} ({})\n", f.name, codes.join(", ")));
|
||||
}
|
||||
}
|
||||
for p in &self.emitted {
|
||||
out.push_str(&format!(" emitted: {}\n", p.display()));
|
||||
}
|
||||
out
|
||||
}
|
||||
}
|
||||
|
||||
/// P0 主入口:装载 → 降级 → 定型 → 生成。
|
||||
pub fn prove_path(path: &Path, opts: &ProveOptions) -> Result<Report> {
|
||||
let started = Instant::now();
|
||||
let module = crate::load::load_module(path)
|
||||
.with_context(|| format!("装载 {}", path.display()))?;
|
||||
let source_sha256 = module
|
||||
.source
|
||||
.sha256
|
||||
.clone()
|
||||
.unwrap_or_default();
|
||||
let file_display = display_path(path);
|
||||
|
||||
// ① 装载完成;② 降级(效应表来自 sema;失败时保守 unknown)。
|
||||
let effects = lower::effect_map(path);
|
||||
let (plan, lowered) = lower::build_plan(
|
||||
&module,
|
||||
&source_sha256,
|
||||
&file_display,
|
||||
effects,
|
||||
&opts.allow_opaque,
|
||||
)?;
|
||||
|
||||
// ③ 定型(分支合流等;错误码 proof.type_mismatch)。
|
||||
let mut diagnostics: Vec<Diagnostic> = Vec::new();
|
||||
diagnostics.extend(types::typecheck_plan(&module, &lowered, opts.strict_types));
|
||||
|
||||
// ④ 生成(--report-only 时跳过写盘)。
|
||||
let mut emitted: Vec<PathBuf> = Vec::new();
|
||||
if !opts.report_only {
|
||||
let dir = match &opts.emit_dir {
|
||||
Some(dir) => dir.clone(),
|
||||
None => default_emit_dir(&source_sha256),
|
||||
};
|
||||
let generated = dir.join("Generated");
|
||||
std::fs::create_dir_all(&generated)
|
||||
.with_context(|| format!("创建 {}", generated.display()))?;
|
||||
let (file_name, lean) = emit::emit_module(&plan, &emit::stem_of(&file_display));
|
||||
let lean_path = generated.join(&file_name);
|
||||
std::fs::write(&lean_path, &lean)
|
||||
.with_context(|| format!("写入 {}", lean_path.display()))?;
|
||||
let plan_path = dir.join("plan.json");
|
||||
std::fs::write(&plan_path, plan.to_stable_json())
|
||||
.with_context(|| format!("写入 {}", plan_path.display()))?;
|
||||
emitted.push(relative_cwd(&lean_path));
|
||||
emitted.push(relative_cwd(&plan_path));
|
||||
}
|
||||
|
||||
// 汇总:错误诊断 → error;有拒绝函数 → rejected;否则 unverified。
|
||||
let has_type_errors = diagnostics
|
||||
.iter()
|
||||
.any(|d| matches!(d.severity, crate::diagnostics::Severity::Error));
|
||||
let functions = summarize(&lowered, &opts.only);
|
||||
let mut status = Verdict::Unverified;
|
||||
if !functions.is_empty() {
|
||||
status = functions
|
||||
.iter()
|
||||
.map(|f| f.verdict)
|
||||
.fold(Verdict::Proved, Verdict::worst);
|
||||
}
|
||||
if has_type_errors {
|
||||
status = Verdict::Error;
|
||||
}
|
||||
|
||||
Ok(Report {
|
||||
file: file_display,
|
||||
source_sha256,
|
||||
status,
|
||||
functions,
|
||||
diagnostics,
|
||||
emitted,
|
||||
duration_ms: started.elapsed().as_millis(),
|
||||
})
|
||||
}
|
||||
|
||||
fn summarize(lowered: &[Lowered], only: &[String]) -> Vec<FunctionReport> {
|
||||
lowered
|
||||
.iter()
|
||||
.filter(|l| !l.is_object)
|
||||
.filter(|l| only.is_empty() || only.iter().any(|name| name == &l.display))
|
||||
.map(|l| {
|
||||
let (verdict, tier, ops, rejected, claims) = match &l.plan {
|
||||
Some(plan) => (
|
||||
Verdict::Unverified,
|
||||
Tier::None,
|
||||
plan.ops
|
||||
.iter()
|
||||
.map(|op| (op.id.clone(), op.effect.clone()))
|
||||
.collect(),
|
||||
Vec::new(),
|
||||
plan.claims
|
||||
.iter()
|
||||
.map(|c| {
|
||||
(
|
||||
c.id.clone(),
|
||||
c.premise.clone(),
|
||||
c.conclusion.clone(),
|
||||
c.tactic.clone(),
|
||||
)
|
||||
})
|
||||
.collect(),
|
||||
),
|
||||
None => (
|
||||
Verdict::Rejected,
|
||||
Tier::None,
|
||||
Vec::new(),
|
||||
l.rejected
|
||||
.iter()
|
||||
.map(|d| {
|
||||
(
|
||||
d.code.clone(),
|
||||
d.message.clone(),
|
||||
d.span.line,
|
||||
)
|
||||
})
|
||||
.collect(),
|
||||
Vec::new(),
|
||||
),
|
||||
};
|
||||
FunctionReport {
|
||||
name: l.display.clone(),
|
||||
verdict,
|
||||
tier,
|
||||
ops,
|
||||
rejected,
|
||||
claims,
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// 默认产物目录:`.marqdo/prove/<key8>/`(key = 源 sha256 前 8 位)。
|
||||
pub fn default_emit_dir(source_sha256: &str) -> PathBuf {
|
||||
PathBuf::from(".marqdo/prove").join(&source_sha256[..source_sha256.len().min(8)])
|
||||
}
|
||||
|
||||
/// `prove clean`:删除 `.marqdo/prove`(--emit 指定目录不动)。
|
||||
pub fn clean() -> Result<usize> {
|
||||
let root = Path::new(".marqdo/prove");
|
||||
if !root.exists() {
|
||||
return Ok(0);
|
||||
}
|
||||
let count = std::fs::read_dir(root)?.count();
|
||||
std::fs::remove_dir_all(root)
|
||||
.with_context(|| format!("删除 {}", root.display()))?;
|
||||
Ok(count)
|
||||
}
|
||||
|
||||
fn display_path(path: &Path) -> String {
|
||||
let cwd = std::env::current_dir().unwrap_or_default();
|
||||
path.strip_prefix(&cwd)
|
||||
.unwrap_or(path)
|
||||
.to_string_lossy()
|
||||
.to_string()
|
||||
}
|
||||
|
||||
fn relative_cwd(path: &Path) -> PathBuf {
|
||||
let cwd = std::env::current_dir().unwrap_or_default();
|
||||
path.strip_prefix(&cwd).unwrap_or(path).to_path_buf()
|
||||
}
|
||||
@@ -0,0 +1,842 @@
|
||||
//! `check --proof`:定理表的静态校验(设计 §7;默认关)。
|
||||
//!
|
||||
//! 校验项(全部 advisory 之外都是 Error 级诊断):
|
||||
//! - `proof.claim_malformed` 表头命中定理词表但列形不齐
|
||||
//! - `proof.claim_ambiguous` 同时有 `类型` 与 `结论` 列
|
||||
//! - `proof.claim_misplaced` 合法定理表出现在首条可执行语句之后
|
||||
//! - `proof.claim_duplicate` 同一函数内定理 id 重复
|
||||
//! - `proof.claim_unknown_symbol` 结论/前提引用了受限符号集之外的名字
|
||||
//! - `proof.claim_unsupported` 谓词超出封闭集合(包含/长度/下标)或元数不对
|
||||
//! - `proof.name_shadow` 保留名(`结果`/`轨迹`)被形参/局部变量遮蔽
|
||||
|
||||
use std::path::Path;
|
||||
|
||||
use crate::ast::{Expr, Function, Module, Stmt};
|
||||
use crate::contract;
|
||||
use crate::diagnostics::{Diagnostic, Severity, Span};
|
||||
|
||||
/// 定理作用域保留名(§7.3.4)。
|
||||
pub const RESERVED_CLAIM_NAMES: &[&str] = &["结果", "轨迹"];
|
||||
|
||||
/// 谓词封闭集合(§7.3.5:改集合需重新评审 ADR)。
|
||||
pub const PREDICATES: &[(&str, usize)] = &[("包含", 2), ("长度", 1), ("下标", 2)];
|
||||
|
||||
/// 入口:对整个模块做定理表校验。
|
||||
pub fn check_proofs(module: &Module, path: Option<&Path>) -> Vec<Diagnostic> {
|
||||
let mut out = Vec::new();
|
||||
let mut function_names: Vec<String> = Vec::new();
|
||||
collect_function_names(module, &mut function_names);
|
||||
let has_claims = module_has_claims(module);
|
||||
walk_checks(
|
||||
module,
|
||||
&module.functions,
|
||||
path,
|
||||
&function_names,
|
||||
has_claims,
|
||||
&mut out,
|
||||
);
|
||||
for (_, child) in module.import_modules.iter() {
|
||||
out.extend(check_proofs_imported(child, path));
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn check_proofs_imported(module: &Module, path: Option<&Path>) -> Vec<Diagnostic> {
|
||||
// import 的库文件自带定理表也按同规则校验(诊断指向本文件行号即可)。
|
||||
let mut out = Vec::new();
|
||||
let mut function_names: Vec<String> = Vec::new();
|
||||
collect_function_names(module, &mut function_names);
|
||||
let has_claims = module_has_claims(module);
|
||||
walk_checks(
|
||||
module,
|
||||
&module.functions,
|
||||
path,
|
||||
&function_names,
|
||||
has_claims,
|
||||
&mut out,
|
||||
);
|
||||
out
|
||||
}
|
||||
|
||||
fn collect_function_names(module: &Module, out: &mut Vec<String>) {
|
||||
fn go(funs: &[Function], out: &mut Vec<String>) {
|
||||
for f in funs {
|
||||
out.push(f.name.clone());
|
||||
go(&f.children, out);
|
||||
}
|
||||
}
|
||||
go(&module.functions, out);
|
||||
for child in module.import_modules.values() {
|
||||
collect_function_names(child, out);
|
||||
}
|
||||
}
|
||||
|
||||
fn module_has_claims(module: &Module) -> bool {
|
||||
fn go(funs: &[Function]) -> bool {
|
||||
funs.iter()
|
||||
.any(|f| !f.claims.is_empty() || go(&f.children))
|
||||
}
|
||||
go(&module.functions)
|
||||
|| module
|
||||
.import_modules
|
||||
.values()
|
||||
.any(|m| module_has_claims(m))
|
||||
}
|
||||
|
||||
fn walk_checks(
|
||||
module: &Module,
|
||||
funs: &[Function],
|
||||
path: Option<&Path>,
|
||||
function_names: &[String],
|
||||
has_claims: bool,
|
||||
out: &mut Vec<Diagnostic>,
|
||||
) {
|
||||
for fun in funs {
|
||||
check_claim_duplicates(module, fun, path, out);
|
||||
check_name_shadow(module, fun, function_names, has_claims, path, out);
|
||||
check_misplaced_and_malformed(module, fun, path, out);
|
||||
check_claim_symbols(module, fun, path, out);
|
||||
walk_checks(module, &fun.children, path, function_names, has_claims, out);
|
||||
}
|
||||
}
|
||||
|
||||
fn proof_diag(
|
||||
module: &Module,
|
||||
path: Option<&Path>,
|
||||
span: Span,
|
||||
code: &str,
|
||||
message: String,
|
||||
suggestion: String,
|
||||
) -> Diagnostic {
|
||||
let _ = module;
|
||||
Diagnostic::new(path, span, message)
|
||||
.with_code(code)
|
||||
.with_severity(Severity::Error)
|
||||
.with_suggestion(suggestion)
|
||||
}
|
||||
|
||||
/// 同一函数内定理 id 重复(§7.1 规则 3)。
|
||||
fn check_claim_duplicates(module: &Module, fun: &Function, path: Option<&Path>, out: &mut Vec<Diagnostic>) {
|
||||
let mut seen: Vec<&str> = Vec::new();
|
||||
for claim in &fun.claims {
|
||||
if seen.contains(&claim.id.as_str()) {
|
||||
out.push(proof_diag(
|
||||
module,
|
||||
path,
|
||||
Span::new(claim.line, 1),
|
||||
"proof.claim_duplicate",
|
||||
format!("定理 `{}` 在 `{}` 内重复声明", claim.id, fun.name),
|
||||
"定理 id 在函数内必须唯一;重命名或删除重复行".into(),
|
||||
));
|
||||
} else {
|
||||
seen.push(&claim.id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 遮蔽检查(§7.3.4):保留名 `结果`/`轨迹` 不得被形参占用;
|
||||
/// 谓词名 `包含/长度/下标` 不得与用户函数同名(有定理表时才有意义)。
|
||||
fn check_name_shadow(
|
||||
module: &Module,
|
||||
fun: &Function,
|
||||
function_names: &[String],
|
||||
has_claims: bool,
|
||||
path: Option<&Path>,
|
||||
out: &mut Vec<Diagnostic>,
|
||||
) {
|
||||
if fun.claims.is_empty() && !has_claims {
|
||||
return;
|
||||
}
|
||||
for param in &fun.params {
|
||||
if RESERVED_CLAIM_NAMES.contains(¶m.name.as_str()) {
|
||||
out.push(proof_diag(
|
||||
module,
|
||||
path,
|
||||
param.span,
|
||||
"proof.name_shadow",
|
||||
format!(
|
||||
"形参 `{}` 与定理作用域保留名冲突(`{}` 也要声明定理)",
|
||||
param.name,
|
||||
fun.name
|
||||
),
|
||||
format!("把形参 `{}` 改名;`结果`/`轨迹` 在定理里指返回值与操作轨迹", param.name),
|
||||
));
|
||||
}
|
||||
}
|
||||
for pred in PREDICATES {
|
||||
if function_names.iter().any(|n| n == pred.0) {
|
||||
out.push(proof_diag(
|
||||
module,
|
||||
path,
|
||||
fun.span,
|
||||
"proof.name_shadow",
|
||||
format!(
|
||||
"函数名 `{}` 与定理谓词 `{}` 同名(谓词集合封闭:包含/长度/下标)",
|
||||
fun.name, pred.0
|
||||
),
|
||||
format!("把函数 `{}` 改名,避免定理表里的 `{}` 歧义", fun.name, pred.0),
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 错位与畸形:body 里仍是定理形的表(默认关时解析器不提取它们)。
|
||||
fn check_misplaced_and_malformed(
|
||||
module: &Module,
|
||||
fun: &Function,
|
||||
path: Option<&Path>,
|
||||
out: &mut Vec<Diagnostic>,
|
||||
) {
|
||||
let mut prefix_zone = true;
|
||||
for stmt in &fun.body {
|
||||
let (pairs, span) = match stmt {
|
||||
Stmt::Expr {
|
||||
value: Expr::Map(pairs),
|
||||
span,
|
||||
} => (pairs, *span),
|
||||
Stmt::Expr { value: Expr::List(_), .. } => continue,
|
||||
_ => {
|
||||
prefix_zone = false;
|
||||
continue;
|
||||
}
|
||||
};
|
||||
match contract::parse_claim_table(pairs, span.line) {
|
||||
Some(Ok(_rows)) => {
|
||||
// 合法定理形却还在 body:一定是位置不对(prefix zone 内会被提取)。
|
||||
out.push(proof_diag(
|
||||
module,
|
||||
path,
|
||||
span,
|
||||
"proof.claim_misplaced",
|
||||
format!(
|
||||
"`{}` 的定理表出现在首条可执行语句之后——它是普通表,不会成为定理",
|
||||
fun.name
|
||||
),
|
||||
"把定理表移到函数体开头(与契约表同一槽位)".into(),
|
||||
));
|
||||
}
|
||||
Some(Err(err)) => {
|
||||
out.push(proof_diag(
|
||||
module,
|
||||
path,
|
||||
span,
|
||||
err.code,
|
||||
err.message,
|
||||
"对照定理表形状:| 定理 | 结论 | 前提 | 策略 |(前提/策略可省)".into(),
|
||||
));
|
||||
}
|
||||
None => {}
|
||||
}
|
||||
let _ = prefix_zone;
|
||||
}
|
||||
}
|
||||
|
||||
/// 受限符号集校验(§7.1 规则 4):前提只看形参;结论可加 `结果`/`轨迹`。
|
||||
fn check_claim_symbols(module: &Module, fun: &Function, path: Option<&Path>, out: &mut Vec<Diagnostic>) {
|
||||
if fun.claims.is_empty() {
|
||||
return;
|
||||
}
|
||||
let params: Vec<String> = fun.params.iter().map(|p| p.name.clone()).collect();
|
||||
for claim in &fun.claims {
|
||||
if let Some(tactic) = &claim.tactic {
|
||||
if tactic != "auto" && tactic != "none" {
|
||||
out.push(proof_diag(
|
||||
module,
|
||||
path,
|
||||
Span::new(claim.line, 1),
|
||||
"proof.claim_malformed",
|
||||
format!("定理 `{}` 的策略 `{}` 不在 auto/none 内", claim.id, tactic),
|
||||
"策略列只接受 auto(自动)或 none(永远 unverified)".into(),
|
||||
));
|
||||
}
|
||||
}
|
||||
if let Some(premise) = &claim.premise {
|
||||
check_claim_expr(
|
||||
module,
|
||||
path,
|
||||
premise,
|
||||
claim,
|
||||
¶ms,
|
||||
false,
|
||||
out,
|
||||
);
|
||||
}
|
||||
check_claim_expr(module, path, &claim.conclusion, claim, ¶ms, true, out);
|
||||
}
|
||||
}
|
||||
|
||||
fn check_claim_expr(
|
||||
module: &Module,
|
||||
path: Option<&Path>,
|
||||
text: &str,
|
||||
claim: &crate::ast::Claim,
|
||||
params: &[String],
|
||||
conclusion_scope: bool,
|
||||
out: &mut Vec<Diagnostic>,
|
||||
) {
|
||||
let tokens = match tokenize_claim(text) {
|
||||
Ok(t) => t,
|
||||
Err(msg) => {
|
||||
out.push(proof_diag(
|
||||
module,
|
||||
path,
|
||||
Span::new(claim.line, 1),
|
||||
"proof.claim_malformed",
|
||||
format!("定理 `{}` 的表达无法解析:{msg}", claim.id),
|
||||
"受限表达式:名字、数字、字符串、比较/算术/布尔、包含(轨迹,x)/长度(轨迹)/下标(轨迹,i)".into(),
|
||||
));
|
||||
return;
|
||||
}
|
||||
};
|
||||
match parse_claim_expr(&tokens) {
|
||||
Ok((_, ast)) => collect_symbols(
|
||||
module,
|
||||
path,
|
||||
claim,
|
||||
&ast,
|
||||
params,
|
||||
conclusion_scope,
|
||||
out,
|
||||
),
|
||||
Err(msg) => {
|
||||
out.push(proof_diag(
|
||||
module,
|
||||
path,
|
||||
Span::new(claim.line, 1),
|
||||
"proof.claim_malformed",
|
||||
format!("定理 `{}` 的表达无法解析:{msg}", claim.id),
|
||||
"受限表达式:名字、数字、字符串、比较/算术/布尔、包含(轨迹,x)/长度(轨迹)/下标(轨迹,i)".into(),
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- 受限表达式
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub(crate) enum CTok {
|
||||
Name(String),
|
||||
Int(i64),
|
||||
Num(f64),
|
||||
Text(String),
|
||||
Bool(bool),
|
||||
Op(&'static str),
|
||||
LParen,
|
||||
RParen,
|
||||
Comma,
|
||||
Dot,
|
||||
}
|
||||
|
||||
/// 词法:把受限表达文本切成记号(emit 与 check 共用)。
|
||||
pub(crate) fn tokenize_claim(text: &str) -> Result<Vec<CTok>, String> {
|
||||
let mut out = Vec::new();
|
||||
let chars: Vec<char> = text.chars().collect();
|
||||
let mut i = 0usize;
|
||||
while i < chars.len() {
|
||||
let c = chars[i];
|
||||
if c.is_whitespace() {
|
||||
i += 1;
|
||||
continue;
|
||||
}
|
||||
match c {
|
||||
'(' => out.push(CTok::LParen),
|
||||
')' => out.push(CTok::RParen),
|
||||
',' | ',' => out.push(CTok::Comma),
|
||||
'.' | '。' => out.push(CTok::Dot),
|
||||
'"' | '“' | '”' => {
|
||||
// 字符串字面量(到下一个同类引号)。
|
||||
let close = c;
|
||||
let mut j = i + 1;
|
||||
let mut s = String::new();
|
||||
while j < chars.len() && chars[j] != close {
|
||||
s.push(chars[j]);
|
||||
j += 1;
|
||||
}
|
||||
if j >= chars.len() {
|
||||
return Err("字符串没有闭合引号".into());
|
||||
}
|
||||
out.push(CTok::Text(s));
|
||||
i = j;
|
||||
}
|
||||
'`' => {
|
||||
// `` `名字` `` → 名字。
|
||||
let mut j = i + 1;
|
||||
let mut s = String::new();
|
||||
while j < chars.len() && chars[j] != '`' {
|
||||
s.push(chars[j]);
|
||||
j += 1;
|
||||
}
|
||||
if j >= chars.len() {
|
||||
return Err("反引号名没有闭合".into());
|
||||
}
|
||||
out.push(CTok::Name(s));
|
||||
i = j;
|
||||
}
|
||||
'0'..='9' => {
|
||||
let mut j = i;
|
||||
let mut s = String::new();
|
||||
let mut dotted = false;
|
||||
while j < chars.len() && (chars[j].is_ascii_digit() || chars[j] == '.') {
|
||||
if chars[j] == '.' {
|
||||
if dotted {
|
||||
break;
|
||||
}
|
||||
dotted = true;
|
||||
}
|
||||
s.push(chars[j]);
|
||||
j += 1;
|
||||
}
|
||||
if dotted {
|
||||
out.push(CTok::Num(s.parse::<f64>().map_err(|_| "数字解析失败")?));
|
||||
} else {
|
||||
out.push(CTok::Int(s.parse::<i64>().map_err(|_| "整数解析失败")?));
|
||||
}
|
||||
i = j - 1;
|
||||
}
|
||||
'=' => out.push(CTok::Op("=")),
|
||||
'≠' | '!' => out.push(CTok::Op("≠")),
|
||||
'<' => out.push(CTok::Op("<")),
|
||||
'≤' => out.push(CTok::Op("≤")),
|
||||
'>' => out.push(CTok::Op(">")),
|
||||
'≥' => out.push(CTok::Op("≥")),
|
||||
'+' => out.push(CTok::Op("+")),
|
||||
'-' | '−' => out.push(CTok::Op("-")),
|
||||
'*' | '×' => out.push(CTok::Op("*")),
|
||||
'/' | '÷' => out.push(CTok::Op("/")),
|
||||
_ => {
|
||||
// 名字 / 中文词 / 关键字。
|
||||
if c.is_alphanumeric() || c == '_' {
|
||||
let mut j = i;
|
||||
let mut s = String::new();
|
||||
while j < chars.len() && (chars[j].is_alphanumeric() || chars[j] == '_' || chars[j] == '.') {
|
||||
s.push(chars[j]);
|
||||
j += 1;
|
||||
}
|
||||
i = j - 1;
|
||||
match s.as_str() {
|
||||
"且" | "and" => out.push(CTok::Op("且")),
|
||||
"或" | "or" => out.push(CTok::Op("或")),
|
||||
"非" | "not" => out.push(CTok::Op("非")),
|
||||
"真" | "true" | "True" => out.push(CTok::Bool(true)),
|
||||
"假" | "false" | "False" => out.push(CTok::Bool(false)),
|
||||
_ => {
|
||||
// `名字.字段` 已并入 s(含点)。
|
||||
out.push(CTok::Name(s));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
return Err(format!("无法识别的字符 `{c}`"));
|
||||
}
|
||||
}
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
#[allow(dead_code)] // op/字面值记号保留:P1 语义求值与 Lean 脚本生成要用。
|
||||
pub(crate) enum ClaimAst {
|
||||
Lit(CTok),
|
||||
/// 名字(可含 `.字段`;已合并进字符串)。
|
||||
Var(String),
|
||||
Call { name: String, args: Vec<ClaimAst> },
|
||||
Bin { op: &'static str, left: Box<ClaimAst>, right: Box<ClaimAst> },
|
||||
Un { op: &'static str, expr: Box<ClaimAst> },
|
||||
}
|
||||
|
||||
struct P<'a> {
|
||||
toks: &'a [CTok],
|
||||
pos: usize,
|
||||
}
|
||||
|
||||
impl<'a> P<'a> {
|
||||
fn peek(&self) -> Option<&CTok> {
|
||||
self.toks.get(self.pos)
|
||||
}
|
||||
fn next(&mut self) -> Option<CTok> {
|
||||
let t = self.toks.get(self.pos).cloned();
|
||||
if t.is_some() {
|
||||
self.pos += 1;
|
||||
}
|
||||
t
|
||||
}
|
||||
fn eat_op(&mut self, ops: &[&str]) -> Option<&'static str> {
|
||||
let CTok::Op(o) = self.peek()? else {
|
||||
return None;
|
||||
};
|
||||
if !ops.contains(o) {
|
||||
return None;
|
||||
}
|
||||
let hit: &'static str = match *o {
|
||||
"+" => "+",
|
||||
"-" => "-",
|
||||
"*" => "*",
|
||||
"/" => "/",
|
||||
"=" => "=",
|
||||
"≠" => "≠",
|
||||
"<" => "<",
|
||||
"≤" => "≤",
|
||||
">" => ">",
|
||||
"≥" => "≥",
|
||||
"且" => "且",
|
||||
"或" => "或",
|
||||
"非" => "非",
|
||||
_ => return None,
|
||||
};
|
||||
self.pos += 1;
|
||||
Some(hit)
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn parse_claim_expr(toks: &[CTok]) -> Result<(Vec<CTok>, ClaimAst), String> {
|
||||
let mut p = P { toks, pos: 0 };
|
||||
let ast = parse_or(&mut p)?;
|
||||
if p.pos != toks.len() {
|
||||
return Err(format!("表达式末尾有多余内容(第 {} 个记号起)", p.pos + 1));
|
||||
}
|
||||
Ok((toks.to_vec(), ast))
|
||||
}
|
||||
|
||||
fn parse_or(p: &mut P) -> Result<ClaimAst, String> {
|
||||
let mut left = parse_and(p)?;
|
||||
while let Some(op) = p.eat_op(&["或"]) {
|
||||
let right = parse_and(p)?;
|
||||
left = ClaimAst::Bin { op, left: Box::new(left), right: Box::new(right) };
|
||||
}
|
||||
Ok(left)
|
||||
}
|
||||
|
||||
fn parse_and(p: &mut P) -> Result<ClaimAst, String> {
|
||||
let mut left = parse_cmp(p)?;
|
||||
while let Some(op) = p.eat_op(&["且"]) {
|
||||
let right = parse_cmp(p)?;
|
||||
left = ClaimAst::Bin { op, left: Box::new(left), right: Box::new(right) };
|
||||
}
|
||||
Ok(left)
|
||||
}
|
||||
|
||||
fn parse_cmp(p: &mut P) -> Result<ClaimAst, String> {
|
||||
let left = parse_add(p)?;
|
||||
if let Some(op) = p.eat_op(&["=", "≠", "<", "≤", ">", "≥"]) {
|
||||
let right = parse_add(p)?;
|
||||
return Ok(ClaimAst::Bin { op, left: Box::new(left), right: Box::new(right) });
|
||||
}
|
||||
Ok(left)
|
||||
}
|
||||
|
||||
fn parse_add(p: &mut P) -> Result<ClaimAst, String> {
|
||||
let mut left = parse_mul(p)?;
|
||||
while let Some(op) = p.eat_op(&["+", "-"]) {
|
||||
let right = parse_mul(p)?;
|
||||
left = ClaimAst::Bin { op, left: Box::new(left), right: Box::new(right) };
|
||||
}
|
||||
Ok(left)
|
||||
}
|
||||
|
||||
fn parse_mul(p: &mut P) -> Result<ClaimAst, String> {
|
||||
let mut left = parse_unary(p)?;
|
||||
while let Some(op) = p.eat_op(&["*", "/"]) {
|
||||
let right = parse_unary(p)?;
|
||||
left = ClaimAst::Bin { op, left: Box::new(left), right: Box::new(right) };
|
||||
}
|
||||
Ok(left)
|
||||
}
|
||||
|
||||
fn parse_unary(p: &mut P) -> Result<ClaimAst, String> {
|
||||
if let Some(op) = p.eat_op(&["非"]) {
|
||||
let expr = parse_unary(p)?;
|
||||
return Ok(ClaimAst::Un { op, expr: Box::new(expr) });
|
||||
}
|
||||
if let Some(CTok::Op("-")) = p.peek() {
|
||||
p.pos += 1;
|
||||
let expr = parse_unary(p)?;
|
||||
return Ok(ClaimAst::Un { op: "-", expr: Box::new(expr) });
|
||||
}
|
||||
parse_atom(p)
|
||||
}
|
||||
|
||||
fn parse_atom(p: &mut P) -> Result<ClaimAst, String> {
|
||||
match p.next() {
|
||||
Some(CTok::LParen) => {
|
||||
let e = parse_or(p)?;
|
||||
match p.next() {
|
||||
Some(CTok::RParen) => Ok(e),
|
||||
_ => Err("缺少右括号".into()),
|
||||
}
|
||||
}
|
||||
Some(t @ (CTok::Int(_) | CTok::Num(_) | CTok::Text(_) | CTok::Bool(_))) => Ok(ClaimAst::Lit(t)),
|
||||
Some(CTok::Name(name)) => {
|
||||
// 谓词调用:名字后紧跟 `(`。
|
||||
if matches!(p.peek(), Some(CTok::LParen)) {
|
||||
p.pos += 1;
|
||||
let mut args = Vec::new();
|
||||
if !matches!(p.peek(), Some(CTok::RParen)) {
|
||||
loop {
|
||||
args.push(parse_or(p)?);
|
||||
match p.next() {
|
||||
Some(CTok::Comma) => continue,
|
||||
Some(CTok::RParen) => break,
|
||||
_ => return Err("调用参数列表未闭合".into()),
|
||||
}
|
||||
}
|
||||
} else {
|
||||
p.pos += 1;
|
||||
}
|
||||
return Ok(ClaimAst::Call { name, args });
|
||||
}
|
||||
Ok(ClaimAst::Var(name))
|
||||
}
|
||||
other => Err(format!("这里应该是一个名字或值,得到 {other:?}")),
|
||||
}
|
||||
}
|
||||
|
||||
/// 收集受限符号并校验(§7.1 规则 4 + §7.3.5 谓词封闭)。
|
||||
fn collect_symbols(
|
||||
module: &Module,
|
||||
path: Option<&Path>,
|
||||
claim: &crate::ast::Claim,
|
||||
ast: &ClaimAst,
|
||||
params: &[String],
|
||||
conclusion_scope: bool,
|
||||
out: &mut Vec<Diagnostic>,
|
||||
) {
|
||||
match ast {
|
||||
ClaimAst::Lit(_) => {}
|
||||
ClaimAst::Var(name) => {
|
||||
// 名字可带 `.字段`(结果.ok / 回执.value)——只校验根名字。
|
||||
let root = name.split('.').next().unwrap_or(name);
|
||||
let known = params.contains(&root.to_string())
|
||||
|| (conclusion_scope && RESERVED_CLAIM_NAMES.contains(&root));
|
||||
if !known {
|
||||
let suggestion = crate::check::suggest_closest(root, params);
|
||||
let mut d = proof_diag(
|
||||
module,
|
||||
path,
|
||||
Span::new(claim.line, 1),
|
||||
"proof.claim_unknown_symbol",
|
||||
format!(
|
||||
"定理 `{}` 引用了未知名字 `{root}`({}作用域只允许{})",
|
||||
claim.id,
|
||||
if conclusion_scope { "结论" } else { "前提" },
|
||||
if conclusion_scope {
|
||||
"形参、结果、轨迹"
|
||||
} else {
|
||||
"形参"
|
||||
}
|
||||
),
|
||||
suggestion
|
||||
.map(|s| format!("是不是想写 `{s}`?"))
|
||||
.unwrap_or_else(|| {
|
||||
if conclusion_scope {
|
||||
"只引用形参与 `结果`/`轨迹`".into()
|
||||
} else {
|
||||
"前提里只引用形参(入口状态求值)".into()
|
||||
}
|
||||
}),
|
||||
);
|
||||
d = d.with_severity(Severity::Error);
|
||||
out.push(d);
|
||||
}
|
||||
}
|
||||
ClaimAst::Call { name, args } => {
|
||||
match PREDICATES.iter().find(|(n, _)| n == name) {
|
||||
Some((_, arity)) if *arity == args.len() => {}
|
||||
Some((_, arity)) => out.push(proof_diag(
|
||||
module,
|
||||
path,
|
||||
Span::new(claim.line, 1),
|
||||
"proof.claim_unsupported",
|
||||
format!(
|
||||
"谓词 `{name}` 需要 {arity} 个参数,定理 `{}` 给了 {} 个",
|
||||
claim.id,
|
||||
args.len()
|
||||
),
|
||||
"谓词集合封闭:包含(轨迹,x) / 长度(轨迹) / 下标(轨迹,i)".into(),
|
||||
)),
|
||||
None => out.push(proof_diag(
|
||||
module,
|
||||
path,
|
||||
Span::new(claim.line, 1),
|
||||
"proof.claim_unsupported",
|
||||
format!(
|
||||
"定理 `{}` 调用了 `{name}`——定理里只能用包含/长度/下标三个谓词",
|
||||
claim.id
|
||||
),
|
||||
"谓词集合封闭(§7.3.5);要扩集合先改 ADR 0010".into(),
|
||||
)),
|
||||
}
|
||||
for arg in args {
|
||||
collect_symbols(module, path, claim, arg, params, conclusion_scope, out);
|
||||
}
|
||||
}
|
||||
ClaimAst::Bin { left, right, .. } => {
|
||||
collect_symbols(module, path, claim, left, params, conclusion_scope, out);
|
||||
collect_symbols(module, path, claim, right, params, conclusion_scope, out);
|
||||
}
|
||||
ClaimAst::Un { expr, .. } => {
|
||||
collect_symbols(module, path, claim, expr, params, conclusion_scope, out);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn parse_ok(text: &str) -> ClaimAst {
|
||||
let toks = tokenize_claim(text).expect("tokenize");
|
||||
parse_claim_expr(&toks).expect("parse").1
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn restricted_grammar_parses_design_examples() {
|
||||
// 设计 §7.1 的示例句全部可解析。
|
||||
let _ = parse_ok("包含(轨迹, \"人工审核\")");
|
||||
let _ = parse_ok("金额 > 10000");
|
||||
let _ = parse_ok("结果.ok = True");
|
||||
let _ = parse_ok("长度(轨迹) = 2");
|
||||
let _ = parse_ok("下标(轨迹, 0) = \"x\"");
|
||||
let _ = parse_ok("非 结果.ok = False 且 金额 ≥ 0");
|
||||
let _ = parse_ok("金额 + 1 ≤ 10 或 假");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tokenizer_rejects_unterminated_strings() {
|
||||
assert!(tokenize_claim("包含(轨迹, \"未闭合").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reserved_outputs_render_without_field_access_prefix() {
|
||||
// emit 侧翻译:结果/轨迹 是定理作用域绑定名,不加 v_ 前缀。
|
||||
let ast = parse_ok("轨迹");
|
||||
assert!(matches!(ast, ClaimAst::Var(ref n) if n == "轨迹"));
|
||||
let ast = parse_ok("结果.ok");
|
||||
assert!(matches!(ast, ClaimAst::Var(ref n) if n == "结果.ok"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn symbol_check_reports_unknown_and_suggests() {
|
||||
let module = Module::default();
|
||||
let claim = crate::ast::Claim {
|
||||
id: "引用未知".into(),
|
||||
conclusion: "额度 > 0".into(),
|
||||
premise: None,
|
||||
tactic: Some("auto".into()),
|
||||
line: 3,
|
||||
};
|
||||
let mut out = Vec::new();
|
||||
check_claim_expr(
|
||||
&module,
|
||||
None,
|
||||
"额度 > 0",
|
||||
&claim,
|
||||
&["金额".to_string()],
|
||||
true,
|
||||
&mut out,
|
||||
);
|
||||
assert_eq!(out.len(), 1);
|
||||
assert_eq!(out[0].code, "proof.claim_unknown_symbol");
|
||||
// 最近建议(编辑距离):额度 → 金额 不够近,无建议也要有消息。
|
||||
assert!(out[0].message.contains("额度"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn symbol_check_accepts_params_in_premise_and_outputs_in_conclusion() {
|
||||
let module = Module::default();
|
||||
let claim = crate::ast::Claim {
|
||||
id: "合法".into(),
|
||||
conclusion: "结果.ok = True".into(),
|
||||
premise: Some("金额 > 0".into()),
|
||||
tactic: None,
|
||||
line: 1,
|
||||
};
|
||||
let mut out = Vec::new();
|
||||
check_claim_expr(
|
||||
&module,
|
||||
None,
|
||||
"金额 > 0",
|
||||
&claim,
|
||||
&["金额".to_string()],
|
||||
false,
|
||||
&mut out,
|
||||
);
|
||||
check_claim_expr(
|
||||
&module,
|
||||
None,
|
||||
"结果.ok = True",
|
||||
&claim,
|
||||
&["金额".to_string()],
|
||||
true,
|
||||
&mut out,
|
||||
);
|
||||
assert!(out.is_empty(), "{out:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn premise_may_not_reference_outputs() {
|
||||
let module = Module::default();
|
||||
let claim = crate::ast::Claim {
|
||||
id: "前提越界".into(),
|
||||
conclusion: "结果.ok = True".into(),
|
||||
premise: Some("轨迹 = 0".into()),
|
||||
tactic: None,
|
||||
line: 1,
|
||||
};
|
||||
let mut out = Vec::new();
|
||||
check_claim_expr(
|
||||
&module,
|
||||
None,
|
||||
"轨迹 = 0",
|
||||
&claim,
|
||||
&[],
|
||||
false,
|
||||
&mut out,
|
||||
);
|
||||
assert!(out
|
||||
.iter()
|
||||
.any(|d| d.code == "proof.claim_unknown_symbol"), "{out:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn predicate_arity_and_closure_are_enforced() {
|
||||
let module = Module::default();
|
||||
let claim = crate::ast::Claim {
|
||||
id: "元数错".into(),
|
||||
conclusion: "包含(轨迹, \"a\", \"b\")".into(),
|
||||
premise: None,
|
||||
tactic: None,
|
||||
line: 1,
|
||||
};
|
||||
let mut out = Vec::new();
|
||||
check_claim_expr(
|
||||
&module,
|
||||
None,
|
||||
"包含(轨迹, \"a\", \"b\")",
|
||||
&claim,
|
||||
&[],
|
||||
true,
|
||||
&mut out,
|
||||
);
|
||||
assert!(out.iter().any(|d| d.code == "proof.claim_unsupported"), "{out:?}");
|
||||
|
||||
let claim2 = crate::ast::Claim {
|
||||
id: "越界谓词".into(),
|
||||
conclusion: "求和(金额, 1) > 0".into(),
|
||||
premise: None,
|
||||
tactic: None,
|
||||
line: 2,
|
||||
};
|
||||
let mut out2 = Vec::new();
|
||||
check_claim_expr(
|
||||
&module,
|
||||
None,
|
||||
"求和(金额, 1) > 0",
|
||||
&claim2,
|
||||
&["金额".to_string()],
|
||||
true,
|
||||
&mut out2,
|
||||
);
|
||||
assert!(out2.iter().any(|d| d.code == "proof.claim_unsupported"), "{out2:?}");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,251 @@
|
||||
//! 定型(`doc/design/prove-cli.md` §4.1 ③):契约表驱动的轻量推断。
|
||||
//!
|
||||
//! P0 范围:参数/返回类型来自契约表;字面量赋值给最具体类型;分支合流时
|
||||
//! 同名变量类型不相容报 `proof.type_mismatch`(带两处行号)。其余一律
|
||||
//! `Any`(`--no-strict-types` 语义下的诚实回退,不做猜测)。
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use crate::diagnostics::{Diagnostic, Severity, Span};
|
||||
use crate::prove::ir::{PlanTy, PureExpr, Step};
|
||||
|
||||
/// 单函数类型检查产物。
|
||||
#[derive(Debug, Default)]
|
||||
pub struct Typed {
|
||||
pub diagnostics: Vec<Diagnostic>,
|
||||
}
|
||||
|
||||
/// 对一个函数的 steps 做类型检查。
|
||||
///
|
||||
/// `params`:形参类型(契约表)。返回收集到的诊断。
|
||||
pub fn typecheck(
|
||||
module: &crate::ast::Module,
|
||||
params: &[(String, PlanTy)],
|
||||
steps: &[Step],
|
||||
strict: bool,
|
||||
) -> Typed {
|
||||
let mut env: BTreeMap<String, (PlanTy, u32)> = params
|
||||
.iter()
|
||||
.map(|(name, ty)| (name.clone(), (ty.clone(), 0)))
|
||||
.collect();
|
||||
let mut diagnostics = Vec::new();
|
||||
check_steps(module, steps, &mut env, &mut diagnostics, strict);
|
||||
Typed { diagnostics }
|
||||
}
|
||||
|
||||
fn check_steps(
|
||||
module: &crate::ast::Module,
|
||||
steps: &[Step],
|
||||
env: &mut BTreeMap<String, (PlanTy, u32)>,
|
||||
out: &mut Vec<Diagnostic>,
|
||||
strict: bool,
|
||||
) {
|
||||
for step in steps {
|
||||
match step {
|
||||
Step::Bind { var, expr, line } => {
|
||||
let ty = expr_type(expr, env);
|
||||
match ty {
|
||||
Some(new_ty) => {
|
||||
if let Some((old_ty, old_line)) = env.get(var) {
|
||||
let merged = conflate(old_ty, &new_ty);
|
||||
if merged.is_none() {
|
||||
out.push(mismatch(
|
||||
module,
|
||||
Span::new(*line, 1),
|
||||
*old_line,
|
||||
var,
|
||||
old_ty,
|
||||
&new_ty,
|
||||
));
|
||||
}
|
||||
let merged = merged.unwrap_or(PlanTy::Any);
|
||||
if strict && merged == PlanTy::Any && new_ty != PlanTy::Any {
|
||||
// 严格模式下落 Any 的合流仍允许,但记录在案。
|
||||
}
|
||||
env.insert(var.clone(), (merged, *line));
|
||||
} else {
|
||||
env.insert(var.clone(), (new_ty, *line));
|
||||
}
|
||||
}
|
||||
None => {
|
||||
// 未知类型:保留旧类型(若有),否则 Any。
|
||||
env.entry(var.clone()).or_insert((PlanTy::Any, *line));
|
||||
}
|
||||
}
|
||||
}
|
||||
Step::Return { expr, .. } => {
|
||||
let _ = expr_type(expr, env);
|
||||
}
|
||||
Step::If {
|
||||
then,
|
||||
otherwise,
|
||||
line,
|
||||
..
|
||||
} => {
|
||||
// 分支合流:两臂各自检查后合并同名变量类型。
|
||||
let mut then_env = env.clone();
|
||||
let mut else_env = env.clone();
|
||||
check_steps(module, then, &mut then_env, out, strict);
|
||||
check_steps(module, otherwise, &mut else_env, out, strict);
|
||||
let then_vars: Vec<(String, (PlanTy, u32))> =
|
||||
then_env.iter().map(|(k, v)| (k.clone(), v.clone())).collect();
|
||||
for (name, (then_ty, then_line)) in then_vars {
|
||||
if name.starts_with("实参") {
|
||||
continue;
|
||||
}
|
||||
match else_env.get(&name) {
|
||||
Some((else_ty, else_line)) => {
|
||||
match conflate(&then_ty, else_ty) {
|
||||
Some(merged) => {
|
||||
env.insert(name, (merged, *line));
|
||||
}
|
||||
None => {
|
||||
out.push(mismatch(
|
||||
module,
|
||||
Span::new(then_line.max(1), 1),
|
||||
*else_line,
|
||||
&name,
|
||||
&then_ty,
|
||||
else_ty,
|
||||
));
|
||||
env.insert(name, (PlanTy::Any, *line));
|
||||
}
|
||||
}
|
||||
}
|
||||
None => {
|
||||
env.insert(name, (then_ty, then_line));
|
||||
}
|
||||
}
|
||||
}
|
||||
// 只在 else 出现的变量也进入合流后的环境。
|
||||
for (name, (else_ty, _)) in &else_env {
|
||||
then_env.entry(name.clone()).or_insert((else_ty.clone(), 0));
|
||||
}
|
||||
}
|
||||
Step::Trace { .. } => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 纯表达式的保守类型:只认字面量/构造器/列表/映射/len/access/插值。
|
||||
fn expr_type(expr: &crate::prove::ir::Expr, env: &BTreeMap<String, (PlanTy, u32)>) -> Option<PlanTy> {
|
||||
match expr {
|
||||
crate::prove::ir::Expr::Pure(pure) => pure_type(pure, env),
|
||||
crate::prove::ir::Expr::Op { .. } => None,
|
||||
crate::prove::ir::Expr::Formula | crate::prove::ir::Expr::Code => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn pure_type(pure: &PureExpr, env: &BTreeMap<String, (PlanTy, u32)>) -> Option<PlanTy> {
|
||||
match pure {
|
||||
PureExpr::Int(_) => Some(PlanTy::Int),
|
||||
PureExpr::Num(_) => Some(PlanTy::Num),
|
||||
PureExpr::Bool(_) => Some(PlanTy::Bool),
|
||||
PureExpr::Text(_) => Some(PlanTy::Text),
|
||||
PureExpr::None => Some(PlanTy::Any),
|
||||
PureExpr::Var(name) => env.get(name).map(|(ty, _)| ty.clone()),
|
||||
PureExpr::Bin { operator: op, left, right } => {
|
||||
use crate::prove::ir::BinOp as B;
|
||||
let lt = pure_type(left, env);
|
||||
let rt = pure_type(right, env);
|
||||
match op {
|
||||
B::Add | B::Sub | B::Mul | B::Div => {
|
||||
let lt = lt?;
|
||||
let rt = rt?;
|
||||
match (<, &rt) {
|
||||
(PlanTy::Text, _) | (_, PlanTy::Text) => Some(PlanTy::Text),
|
||||
(PlanTy::Num, _) | (_, PlanTy::Num) => Some(PlanTy::Num),
|
||||
(PlanTy::Int, PlanTy::Int) => Some(PlanTy::Int),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
B::Eq | B::Ne | B::Lt | B::Le | B::Gt | B::Ge | B::And | B::Or => Some(PlanTy::Bool),
|
||||
}
|
||||
}
|
||||
PureExpr::Un { operator: op, expr } => match op {
|
||||
crate::prove::ir::UnOp::Not => Some(PlanTy::Bool),
|
||||
crate::prove::ir::UnOp::Neg => pure_type(expr, env),
|
||||
},
|
||||
PureExpr::Index { base, .. } => match pure_type(base, env)? {
|
||||
PlanTy::Map => Some(PlanTy::Any),
|
||||
PlanTy::List => Some(PlanTy::Any),
|
||||
PlanTy::Result => Some(PlanTy::Any),
|
||||
_ => Some(PlanTy::Any),
|
||||
},
|
||||
PureExpr::Access { base, .. } => match pure_type(base, env)? {
|
||||
PlanTy::Result => Some(PlanTy::Any),
|
||||
_ => Some(PlanTy::Any),
|
||||
},
|
||||
PureExpr::Len(_) => Some(PlanTy::Int),
|
||||
PureExpr::Interp(_) => Some(PlanTy::Text),
|
||||
PureExpr::List(_) => Some(PlanTy::List),
|
||||
PureExpr::Map(_) => Some(PlanTy::Map),
|
||||
PureExpr::Ctor { name, .. } => {
|
||||
if name.starts_with("result.") {
|
||||
Some(PlanTy::Result)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 类型合流:相同 → 相同;Int+Num → Num;含 Any → Any;否则 None(冲突)。
|
||||
fn conflate(a: &PlanTy, b: &PlanTy) -> Option<PlanTy> {
|
||||
use PlanTy as T;
|
||||
if a == b {
|
||||
return Some(a.clone());
|
||||
}
|
||||
match (a, b) {
|
||||
(T::Any, other) | (other, T::Any) => Some(other.clone()),
|
||||
(T::Int, T::Num) | (T::Num, T::Int) => Some(T::Num),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn mismatch(
|
||||
module: &crate::ast::Module,
|
||||
span: Span,
|
||||
other_line: u32,
|
||||
var: &str,
|
||||
old: &PlanTy,
|
||||
new: &PlanTy,
|
||||
) -> Diagnostic {
|
||||
Diagnostic::new(
|
||||
module.source.path.as_deref(),
|
||||
span,
|
||||
format!(
|
||||
"`{var}` 在分支合流处类型不相容:{a} vs {b}",
|
||||
a = old.name(),
|
||||
b = new.name()
|
||||
),
|
||||
)
|
||||
.with_source(&module.source)
|
||||
.with_code("proof.type_mismatch")
|
||||
.with_severity(Severity::Error)
|
||||
.with_suggestion(format!(
|
||||
"另一处绑定在第 {other_line} 行;统一两臂的类型或改用 --no-strict-types"
|
||||
))
|
||||
}
|
||||
|
||||
/// 把类型检查接到降级产物上(mod.rs 调用)。
|
||||
pub fn typecheck_plan(
|
||||
module: &crate::ast::Module,
|
||||
lowered: &[crate::prove::lower::Lowered],
|
||||
strict: bool,
|
||||
) -> Vec<Diagnostic> {
|
||||
let mut out = Vec::new();
|
||||
for item in lowered {
|
||||
let Some(plan) = &item.plan else {
|
||||
continue;
|
||||
};
|
||||
let params: Vec<(String, PlanTy)> = plan
|
||||
.params
|
||||
.iter()
|
||||
.map(|p| (p.name.clone(), p.ty.clone()))
|
||||
.collect();
|
||||
let typed = typecheck(module, ¶ms, &plan.steps, strict);
|
||||
out.extend(typed.diagnostics);
|
||||
}
|
||||
out
|
||||
}
|
||||
@@ -19,8 +19,12 @@ fn line(text: &str, marker: &str) -> u32 {
|
||||
+ 1
|
||||
}
|
||||
fn root(label: &str) -> PathBuf {
|
||||
let dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
||||
.join("target/source-map")
|
||||
// Scratch belongs to the build target dir; honor CARGO_TARGET_DIR when set.
|
||||
let base = std::env::var_os("CARGO_TARGET_DIR")
|
||||
.map(PathBuf::from)
|
||||
.unwrap_or_else(|| PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("target"));
|
||||
let dir = base
|
||||
.join("source-map")
|
||||
.join(format!("{label}-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
dir
|
||||
|
||||
+670
@@ -0,0 +1,670 @@
|
||||
//! `marqdo prove` P0 集成测试(roadmap/prove.md §6 A–H 矩阵的 P0 部分)。
|
||||
//!
|
||||
//! 全部不依赖 Lean:判定在 P1 接入,P0 只验「装载 → 降级 → 定型 → 确定性生成」。
|
||||
//! 每个用例在 `target/` 下的独立临时目录里跑 CLI(与 `Commands::Check` 同款)。
|
||||
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Command;
|
||||
|
||||
struct Scratch {
|
||||
dir: PathBuf,
|
||||
}
|
||||
|
||||
impl Scratch {
|
||||
fn new(name: &str) -> Self {
|
||||
let target = std::env::var_os("CARGO_TARGET_DIR")
|
||||
.map(PathBuf::from)
|
||||
.unwrap_or_else(|| PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("target"));
|
||||
let dir = target.join("prove-tests").join(name);
|
||||
let _ = fs::remove_dir_all(&dir);
|
||||
fs::create_dir_all(&dir).expect("create scratch dir");
|
||||
Self { dir }
|
||||
}
|
||||
|
||||
/// 把 lib/result.mq.md 拷进临时项目(import 相对文档解析)。
|
||||
fn provision_lib(&self) {
|
||||
let src = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("lib/result.mq.md");
|
||||
let dst = self.dir.join("lib/result.mq.md");
|
||||
fs::create_dir_all(self.dir.join("lib")).expect("create lib dir");
|
||||
fs::copy(&src, &dst).expect("copy lib/result.mq.md");
|
||||
}
|
||||
|
||||
fn write(&self, rel: &str, content: &str) -> PathBuf {
|
||||
let path = self.dir.join(rel);
|
||||
if let Some(parent) = path.parent() {
|
||||
fs::create_dir_all(parent).expect("create fixture parent");
|
||||
}
|
||||
fs::write(&path, content).expect("write fixture");
|
||||
path
|
||||
}
|
||||
|
||||
fn run(&self, args: &[&str]) -> Run {
|
||||
let exe: &Path = Path::new(env!("CARGO_BIN_EXE_marqdo"));
|
||||
let output = Command::new(exe)
|
||||
.args(args)
|
||||
.current_dir(&self.dir)
|
||||
.env("MARQDO_RUNTIME_DIR", self.dir.join("runtime"))
|
||||
.output()
|
||||
.expect("run marqdo");
|
||||
Run {
|
||||
code: output.status.code().unwrap_or(1),
|
||||
stdout: String::from_utf8_lossy(&output.stdout).to_string(),
|
||||
stderr: String::from_utf8_lossy(&output.stderr).to_string(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct Run {
|
||||
code: i32,
|
||||
stdout: String,
|
||||
stderr: String,
|
||||
}
|
||||
|
||||
/// 审批样例(roadmap §7 / 设计 §2.5):分支 + 内联 result + 不透明 import。
|
||||
const APPROVAL: &str = r#"---
|
||||
markup: occlusion
|
||||
import:
|
||||
result: lib/result.mq.md
|
||||
---
|
||||
|
||||
审批一个报销申请:大额必须人工审核,小额自动通过。
|
||||
|
||||
# 审批台
|
||||
|
||||
## 审批
|
||||
+ `金额`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| 金额 | int | 申请金额(元) |
|
||||
|
||||
1. `金额` > 10000
|
||||
**回执 = [提交人工审核](人工审核(金额=`金额`))**
|
||||
**结果 = [保留结论](result.ok(value=[取值](access(`回执`, "value"))))**
|
||||
2. *
|
||||
**结果 = [自动通过](result.ok(value="auto"))**
|
||||
|
||||
*结果*
|
||||
|
||||
## 人工审核
|
||||
+ `金额`
|
||||
|
||||
**回执 = [请求送审](工程.送审(金额=`金额`))**
|
||||
|
||||
*回执*
|
||||
"#;
|
||||
|
||||
/// 倒计时:while 循环 → P0 拒绝(proof.while)。
|
||||
const COUNTDOWN: &str = r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
|
||||
# 倒计时器
|
||||
|
||||
## 倒数
|
||||
+ `n`
|
||||
|
||||
**剩余 = `n`**
|
||||
- `剩余` > 0
|
||||
**剩余 = `剩余` - 1**
|
||||
|
||||
*剩余*
|
||||
"#;
|
||||
|
||||
/// 分支后还有 return:两臂都必须带上后续(续延丢失回归测试)。
|
||||
const BRANCH_THEN_RETURN: &str = r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
|
||||
# 盒子
|
||||
|
||||
## 挑选
|
||||
+ `n`
|
||||
|
||||
1. `n` > 0
|
||||
**输出 = "正"**
|
||||
2. *
|
||||
**输出 = "负"**
|
||||
|
||||
*输出*
|
||||
"#;
|
||||
|
||||
/// 裸未知名:动态调用 → 拒绝。
|
||||
const UNKNOWN_CALL: &str = r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
|
||||
# 神秘
|
||||
|
||||
## 执行
|
||||
|
||||
**回执 = [召唤](不存在的函数(`1`))**
|
||||
|
||||
*回执*
|
||||
"#;
|
||||
|
||||
/// 带定理表的审批样例(roadmap §3 / 设计 §7.1;与设计文档示例同形)。
|
||||
const APPROVAL_WITH_CLAIMS: &str = r#"---
|
||||
markup: occlusion
|
||||
import:
|
||||
result: lib/result.mq.md
|
||||
---
|
||||
|
||||
# 审批台
|
||||
|
||||
## 审批
|
||||
+ `金额`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| 金额 | int | 申请金额(元) |
|
||||
|
||||
| 定理 | 结论 | 前提 | 策略 |
|
||||
|---|---|---|---|
|
||||
| 大额必经人工 | 包含(轨迹, "人工审核") | 金额 > 10000 | auto |
|
||||
| 恒有结果 | 结果.ok = True | | auto |
|
||||
|
||||
1. `金额` > 10000
|
||||
**回执 = [提交人工审核](人工审核(金额=`金额`))**
|
||||
**结果 = [保留结论](result.ok(value=[取值](access(`回执`, "value"))))**
|
||||
2. *
|
||||
**结果 = [自动通过](result.ok(value="auto"))**
|
||||
|
||||
*结果*
|
||||
|
||||
## 人工审核
|
||||
+ `金额`
|
||||
|
||||
**回执 = [请求送审](工程.送审(金额=`金额`))**
|
||||
|
||||
*回执*
|
||||
"#;
|
||||
|
||||
fn read(dir: &Path, rel: &str) -> String {
|
||||
fs::read_to_string(dir.join(rel)).unwrap_or_else(|e| panic!("read {rel}: {e}"))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn p0_a_emit_writes_deterministic_artifacts() {
|
||||
let s = Scratch::new("a_deterministic");
|
||||
s.provision_lib();
|
||||
s.write("approval.mq.md", APPROVAL);
|
||||
let r1 = s.run(&["prove", "approval.mq.md", "--emit", "out1"]);
|
||||
assert_eq!(r1.code, 0, "emit1 stderr={}", r1.stderr);
|
||||
let r2 = s.run(&["prove", "approval.mq.md", "--emit", "out2"]);
|
||||
assert_eq!(r2.code, 0, "emit2 stderr={}", r2.stderr);
|
||||
|
||||
for rel in ["out1/plan.json", "out1/Generated/approval_mq.lean"] {
|
||||
assert!(s.dir.join(&rel).is_file(), "missing {rel}");
|
||||
}
|
||||
// 确定性:两次 emit 字节一致(plan + lean)。
|
||||
assert_eq!(
|
||||
read(&s.dir, "out1/plan.json"),
|
||||
read(&s.dir, "out2/plan.json"),
|
||||
"plan.json must be byte-identical"
|
||||
);
|
||||
assert_eq!(
|
||||
read(&s.dir, "out1/Generated/approval_mq.lean"),
|
||||
read(&s.dir, "out2/Generated/approval_mq.lean"),
|
||||
"lean module must be byte-identical"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn p0_b_json_contract_shape() {
|
||||
let s = Scratch::new("b_json_shape");
|
||||
s.provision_lib();
|
||||
s.write("approval.mq.md", APPROVAL);
|
||||
let r = s.run(&["prove", "approval.mq.md", "--report-only", "--json"]);
|
||||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||||
let v: serde_json::Value = serde_json::from_str(&r.stdout).expect("valid JSON");
|
||||
assert_eq!(v["schema"], 1);
|
||||
assert_eq!(v["status"], "unverified");
|
||||
assert_eq!(v["file"], "approval.mq.md");
|
||||
assert!(v["source_sha256"].as_str().is_some_and(|h| h.len() == 64));
|
||||
let functions = v["functions"].as_array().expect("functions array");
|
||||
assert_eq!(functions.len(), 2, "对象不进报告,只有两个函数");
|
||||
let names: Vec<&str> = functions
|
||||
.iter()
|
||||
.map(|f| f["name"].as_str().expect("name"))
|
||||
.collect();
|
||||
assert_eq!(names, vec!["审批台.审批", "审批台.人工审核"]);
|
||||
for f in functions {
|
||||
assert_eq!(f["tier"], "none", "P0 无判定层");
|
||||
assert_eq!(f["status"], "unverified");
|
||||
assert_eq!(f["claims"].as_array().map(Vec::len), Some(0));
|
||||
}
|
||||
// lean 尚未接入(P0 判定在 P1)。
|
||||
assert!(v["lean"].is_null());
|
||||
// emitted 为空(report-only)。
|
||||
assert_eq!(v["emitted"].as_array().map(Vec::len), Some(0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn p0_c_while_loop_rejected_with_code() {
|
||||
let s = Scratch::new("c_while_rejected");
|
||||
s.write("countdown.mq.md", COUNTDOWN);
|
||||
let r = s.run(&["prove", "countdown.mq.md", "--report-only", "--json"]);
|
||||
// 拒绝是建议性(exit 0),不阻断 agent。
|
||||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||||
let v: serde_json::Value = serde_json::from_str(&r.stdout).expect("valid JSON");
|
||||
assert_eq!(v["status"], "rejected");
|
||||
let f = &v["functions"][0];
|
||||
assert_eq!(f["name"], "倒计时器.倒数");
|
||||
assert_eq!(f["status"], "rejected");
|
||||
let rejected = f["rejected"].as_array().expect("rejected array");
|
||||
assert!(
|
||||
rejected
|
||||
.iter()
|
||||
.any(|d| d["code"] == "proof.while"),
|
||||
"expected proof.while, got {rejected:?}"
|
||||
);
|
||||
// 文本面也列出拒绝原因。
|
||||
let t = s.run(&["prove", "countdown.mq.md", "--report-only"]);
|
||||
assert!(t.stdout.contains("proof.while"), "text: {}", t.stdout);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn p0_d_side_effect_import_is_opaque_op() {
|
||||
let s = Scratch::new("d_opaque_op");
|
||||
s.provision_lib();
|
||||
s.write("approval.mq.md", APPROVAL);
|
||||
let r = s.run(&["prove", "approval.mq.md", "--emit", "out"]);
|
||||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||||
let lean = read(&s.dir, "out/Generated/approval_mq.lean");
|
||||
// 工程外部调用:Op 构造器 + Env 查询 + 追踪,不展开。
|
||||
assert!(lean.contains("«调用:工程.送审»"), "op ctor missing:\n{lean}");
|
||||
assert!(lean.contains("env (Op.«调用:工程.送审»"), "env query missing");
|
||||
assert!(lean.contains("[Op.«调用:工程.送审»"), "trace append missing");
|
||||
// result.ok 内联为 Val 构造器,不是 Op。
|
||||
assert!(!lean.contains("result.ok»"), "result.ok must inline, not be an Op");
|
||||
assert!(lean.contains("mqResultOk"), "result.ok → mqResultOk");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn p0_e_allow_opaque_downgrades_whole_function() {
|
||||
let s = Scratch::new("e_allow_opaque");
|
||||
s.write("countdown.mq.md", COUNTDOWN);
|
||||
let r = s.run(&[
|
||||
"prove",
|
||||
"countdown.mq.md",
|
||||
"--report-only",
|
||||
"--json",
|
||||
"--allow-opaque",
|
||||
"倒计时器.倒数",
|
||||
]);
|
||||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||||
let v: serde_json::Value = serde_json::from_str(&r.stdout).expect("valid JSON");
|
||||
assert_eq!(v["status"], "unverified");
|
||||
let f = &v["functions"][0];
|
||||
assert_eq!(f["status"], "unverified");
|
||||
let ops = f["ops"].as_array().expect("ops");
|
||||
assert_eq!(ops.len(), 1, "整函数降级 = 单个 Op");
|
||||
assert_eq!(ops[0]["id"], "调用:倒计时器.倒数");
|
||||
assert_eq!(ops[0]["effect"], "opaque");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn p0_f_branch_continuation_not_swallowed() {
|
||||
let s = Scratch::new("f_continuation");
|
||||
s.write("box.mq.md", BRANCH_THEN_RETURN);
|
||||
let r = s.run(&["prove", "box.mq.md", "--emit", "out"]);
|
||||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||||
let lean = read(&s.dir, "out/Generated/box_mq.lean");
|
||||
// 分支后的 return 必须出现在两个臂里(回归:此前续延被分支吞掉)。
|
||||
assert_eq!(
|
||||
lean.matches("(输出, 轨迹)").count(),
|
||||
2,
|
||||
"return must appear in both arms:\n{lean}"
|
||||
);
|
||||
// 两臂各自绑定。
|
||||
assert!(lean.contains("let 输出 := (Val.text \"正\")"), "{lean}");
|
||||
assert!(lean.contains("let 输出 := (Val.text \"负\")"), "{lean}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn p0_g_mq_line_comments_and_guillemets() {
|
||||
let s = Scratch::new("g_comments");
|
||||
s.provision_lib();
|
||||
s.write("approval.mq.md", APPROVAL);
|
||||
let r = s.run(&["prove", "approval.mq.md", "--emit", "out"]);
|
||||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||||
let lean = read(&s.dir, "out/Generated/approval_mq.lean");
|
||||
assert!(lean.contains("-- mq: "), "溯源注释缺失");
|
||||
// 含点标识符用 guillemets。
|
||||
assert!(lean.contains("«审批台.审批»"), "{lean}");
|
||||
// 确定性来源:无时间戳、无绝对路径。
|
||||
assert!(!lean.contains("marqdo/prove/"), "must not leak default dir");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn p0_h_unknown_call_rejected() {
|
||||
let s = Scratch::new("h_unknown");
|
||||
s.write("mystery.mq.md", UNKNOWN_CALL);
|
||||
let r = s.run(&["prove", "mystery.mq.md", "--report-only", "--json"]);
|
||||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||||
let v: serde_json::Value = serde_json::from_str(&r.stdout).expect("valid JSON");
|
||||
assert_eq!(v["status"], "rejected");
|
||||
let rejected = v["functions"][0]["rejected"]
|
||||
.as_array()
|
||||
.expect("rejected array");
|
||||
assert!(
|
||||
rejected.iter().any(|d| d["code"] == "proof.dynamic_call"),
|
||||
"expected proof.dynamic_call, got {rejected:?}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn p0_i_report_only_writes_nothing() {
|
||||
let s = Scratch::new("i_report_only");
|
||||
s.provision_lib();
|
||||
s.write("approval.mq.md", APPROVAL);
|
||||
let r = s.run(&["prove", "approval.mq.md", "--report-only"]);
|
||||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||||
assert!(
|
||||
!s.dir.join(".marqdo").exists(),
|
||||
"report-only must not create artifacts"
|
||||
);
|
||||
assert!(!r.stdout.contains("emitted:"), "no emitted lines");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn p0_j_clean_removes_default_dir() {
|
||||
let s = Scratch::new("j_clean");
|
||||
s.provision_lib();
|
||||
s.write("approval.mq.md", APPROVAL);
|
||||
let r = s.run(&["prove", "approval.mq.md"]);
|
||||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||||
assert!(s.dir.join(".marqdo/prove").exists(), "default emit dir");
|
||||
let r = s.run(&["prove", "clean", "--json"]);
|
||||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||||
assert!(r.stdout.contains("\"ok\":true"), "{}", r.stdout);
|
||||
assert!(!s.dir.join(".marqdo/prove").exists(), "clean must remove dir");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn p0_k_branch_type_conflict_is_error() {
|
||||
let s = Scratch::new("k_type_conflict");
|
||||
s.write(
|
||||
"conflict.mq.md",
|
||||
r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
|
||||
# 冲突
|
||||
|
||||
## 挑选
|
||||
+ `n`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| n | int | 数值 |
|
||||
|
||||
1. `n` > 0
|
||||
**输出 = `n`**
|
||||
2. *
|
||||
**输出 = "文字"**
|
||||
|
||||
*输出*
|
||||
"#,
|
||||
);
|
||||
let r = s.run(&["prove", "conflict.mq.md", "--report-only", "--json"]);
|
||||
// error → exit 1(§3.3)。
|
||||
assert_eq!(r.code, 1, "stderr={}", r.stderr);
|
||||
let v: serde_json::Value = serde_json::from_str(&r.stdout).expect("valid JSON");
|
||||
assert_eq!(v["status"], "error");
|
||||
let codes: Vec<&str> = v["diagnostics"]
|
||||
.as_array()
|
||||
.expect("diagnostics")
|
||||
.iter()
|
||||
.filter_map(|d| d["code"].as_str())
|
||||
.collect();
|
||||
assert!(
|
||||
codes.iter().any(|c| *c == "proof.type_mismatch"),
|
||||
"expected proof.type_mismatch, got {codes:?}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn p0_l_only_filters_report() {
|
||||
let s = Scratch::new("l_only");
|
||||
s.provision_lib();
|
||||
s.write("approval.mq.md", APPROVAL);
|
||||
let r = s.run(&[
|
||||
"prove",
|
||||
"approval.mq.md",
|
||||
"--report-only",
|
||||
"--json",
|
||||
"--only",
|
||||
"审批台.人工审核",
|
||||
]);
|
||||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||||
let v: serde_json::Value = serde_json::from_str(&r.stdout).expect("valid JSON");
|
||||
let functions = v["functions"].as_array().expect("functions");
|
||||
assert_eq!(functions.len(), 1);
|
||||
assert_eq!(functions[0]["name"], "审批台.人工审核");
|
||||
}
|
||||
|
||||
// ============================================================ P1 · 定理表与 check --proof
|
||||
|
||||
/// 提取后的定理表:claims 非空、body 无该表(roadmap §3 第 1 周验收)。
|
||||
#[test]
|
||||
fn p1_a_claim_table_extracted_and_removed_from_body() {
|
||||
let s = Scratch::new("p1_extract");
|
||||
s.provision_lib();
|
||||
s.write("approval.mq.md", APPROVAL_WITH_CLAIMS);
|
||||
let r = s.run(&["prove", "approval.mq.md", "--report-only", "--json"]);
|
||||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||||
let v: serde_json::Value = serde_json::from_str(&r.stdout).expect("valid JSON");
|
||||
let f = &v["functions"][0];
|
||||
assert_eq!(f["name"], "审批台.审批");
|
||||
let claims = f["claims"].as_array().expect("claims array");
|
||||
assert_eq!(claims.len(), 2, "{claims:?}");
|
||||
assert_eq!(claims[0]["id"], "大额必经人工");
|
||||
assert_eq!(claims[0]["premise"], "金额 > 10000");
|
||||
assert_eq!(claims[0]["conclusion"], "包含(轨迹, \"人工审核\")");
|
||||
assert_eq!(claims[1]["id"], "恒有结果");
|
||||
assert!(claims[1]["premise"].is_null(), "空前提 = 全称命题");
|
||||
// 表从 body 移除:plan 的 steps 里没有表(函数照常降级)。
|
||||
assert_eq!(f["status"], "unverified");
|
||||
}
|
||||
|
||||
/// 定理脚手架进 Lean:受限文法命题 → theorem 陈述 + sorry 占位。
|
||||
#[test]
|
||||
fn p1_b_emit_theorem_scaffold() {
|
||||
let s = Scratch::new("p1_theorem");
|
||||
s.provision_lib();
|
||||
s.write("approval.mq.md", APPROVAL_WITH_CLAIMS);
|
||||
let r = s.run(&["prove", "approval.mq.md", "--emit", "out"]);
|
||||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||||
let lean = read(&s.dir, "out/Generated/approval_mq.lean");
|
||||
assert!(
|
||||
lean.contains("theorem «审批台.审批.大额必经人工»"),
|
||||
"{lean}"
|
||||
);
|
||||
// 前提进绑定;包含(轨迹, …) 翻成操作名成员测试。
|
||||
assert!(lean.contains("(h_前提 : mqTruth (mqGt 金额 (Val.int 10000)))"), "{lean}");
|
||||
assert!(
|
||||
lean.contains("((轨迹.map Op.name).contains \"人工审核\")"),
|
||||
"{lean}"
|
||||
);
|
||||
// 结果.ok → mqAccess 字段读取。
|
||||
assert!(lean.contains("(mqAccess 结果 \"ok\")"), "{lean}");
|
||||
// 策略脚本(§7.2):unfold → split → simp_all/omega。
|
||||
assert!(lean.contains("unfold «审批台.审批» at h_run"), "{lean}");
|
||||
assert!(lean.contains("split at h_run <;> simp_all <;> omega"), "{lean}");
|
||||
}
|
||||
|
||||
/// check --proof(默认关):不传 --proof 时定理问题不报。
|
||||
#[test]
|
||||
fn p1_c_check_proof_off_by_default() {
|
||||
let s = Scratch::new("p1_default_off");
|
||||
s.write(
|
||||
"bad.mq.md",
|
||||
r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
|
||||
# 审计
|
||||
|
||||
## 核对
|
||||
+ `金额`
|
||||
|
||||
| 定理 | 结论 |
|
||||
|---|---|
|
||||
| 引用未知 | 额度 > 0 |
|
||||
|
||||
**x = `金额`**
|
||||
|
||||
*x*
|
||||
"#,
|
||||
);
|
||||
let r = s.run(&["check", "bad.mq.md", "--json"]);
|
||||
assert_eq!(r.code, 0, "默认关:{} {}", r.stdout, r.stderr);
|
||||
assert!(
|
||||
!r.stdout.contains("proof.claim_unknown_symbol"),
|
||||
"默认必须不报:{}",
|
||||
r.stdout
|
||||
);
|
||||
}
|
||||
|
||||
/// check --proof:unknown_symbol + duplicate + misplaced + malformed。
|
||||
#[test]
|
||||
fn p1_d_check_proof_diagnostic_codes() {
|
||||
let s = Scratch::new("p1_codes");
|
||||
s.write(
|
||||
"bad.mq.md",
|
||||
r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
|
||||
# 审计
|
||||
|
||||
## 核对
|
||||
+ `金额`
|
||||
|
||||
| 定理 | 结论 | 前提 | 策略 |
|
||||
|---|---|---|---|
|
||||
| 引用未知 | 长度(轨迹) = 额度 | 金额 > 0 | auto |
|
||||
| 引用未知 | 长度(轨迹) = 额度 | 金额 > 0 | auto |
|
||||
| 坏策略 | 结果.ok = True | | manual |
|
||||
|
||||
**x = `金额`**
|
||||
|
||||
| 定理 | 结论 |
|
||||
|---|---|
|
||||
| 错位表 | 结果.ok = True |
|
||||
|
||||
*x*
|
||||
"#,
|
||||
);
|
||||
let r = s.run(&["check", "bad.mq.md", "--proof", "--json"]);
|
||||
assert_eq!(r.code, 1, "error 级诊断 → 退出 1:{}", r.stdout);
|
||||
assert!(r.stdout.contains("proof.claim_unknown_symbol"), "{}", r.stdout);
|
||||
assert!(r.stdout.contains("proof.claim_duplicate"), "{}", r.stdout);
|
||||
assert!(r.stdout.contains("proof.claim_misplaced"), "{}", r.stdout);
|
||||
assert!(r.stdout.contains("proof.claim_malformed"), "{}", r.stdout);
|
||||
// 不该误报:策略 auto/none 之外的 malformed 只出现一次(坏策略行)。
|
||||
assert_eq!(r.stdout.matches("proof.claim_malformed").count(), 1, "{}", r.stdout);
|
||||
}
|
||||
|
||||
/// check --proof:保留名遮蔽(§7.3.4)。
|
||||
#[test]
|
||||
fn p1_e_check_proof_name_shadow() {
|
||||
let s = Scratch::new("p1_shadow");
|
||||
s.write(
|
||||
"shadow.mq.md",
|
||||
r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
|
||||
# 审计
|
||||
|
||||
## 核对
|
||||
+ `结果`
|
||||
|
||||
| 定理 | 结论 |
|
||||
|---|---|
|
||||
| 恒真 | 结果.ok = True |
|
||||
|
||||
**x = `结果`**
|
||||
|
||||
*x*
|
||||
"#,
|
||||
);
|
||||
let r = s.run(&["check", "shadow.mq.md", "--proof", "--json"]);
|
||||
assert_eq!(r.code, 1, "{}", r.stdout);
|
||||
assert!(r.stdout.contains("proof.name_shadow"), "{}", r.stdout);
|
||||
}
|
||||
|
||||
/// check --proof:歧义表(类型+结论)与谓词元数(§7.1 规则 5 / §7.3.5)。
|
||||
#[test]
|
||||
fn p1_f_check_proof_ambiguous_and_unsupported() {
|
||||
let s = Scratch::new("p1_amb");
|
||||
s.write(
|
||||
"amb.mq.md",
|
||||
r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
|
||||
# 审计
|
||||
|
||||
## 核对
|
||||
+ `金额`
|
||||
|
||||
| 定理 | 类型 | 结论 |
|
||||
|---|---|---|
|
||||
| 歧义 | int | 结果.ok = True |
|
||||
|
||||
**x = `金额`**
|
||||
|
||||
*x*
|
||||
"#,
|
||||
);
|
||||
let r = s.run(&["check", "amb.mq.md", "--proof", "--json"]);
|
||||
assert!(r.stdout.contains("proof.claim_ambiguous"), "{}", r.stdout);
|
||||
|
||||
let s2 = Scratch::new("p1_unsupported");
|
||||
s2.write(
|
||||
"bad2.mq.md",
|
||||
r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
|
||||
# 审计
|
||||
|
||||
## 核对
|
||||
+ `金额`
|
||||
|
||||
| 定理 | 结论 | 策略 |
|
||||
|---|---|---|
|
||||
| 元数错 | 包含(轨迹, "a", "b") | auto |
|
||||
|
||||
**x = `金额`**
|
||||
|
||||
*x*
|
||||
"#,
|
||||
);
|
||||
let r = s2.run(&["check", "bad2.mq.md", "--proof", "--json"]);
|
||||
assert!(r.stdout.contains("proof.claim_unsupported"), "{}", r.stdout);
|
||||
}
|
||||
|
||||
/// 带定理的文件:emit 输出仍然确定性(plan.json + lean 两次一致)。
|
||||
#[test]
|
||||
fn p1_g_emit_with_claims_is_deterministic() {
|
||||
let s = Scratch::new("p1_det");
|
||||
s.provision_lib();
|
||||
s.write("approval.mq.md", APPROVAL_WITH_CLAIMS);
|
||||
s.run(&["prove", "approval.mq.md", "--emit", "out1"]);
|
||||
s.run(&["prove", "approval.mq.md", "--emit", "out2"]);
|
||||
assert_eq!(
|
||||
read(&s.dir, "out1/Generated/approval_mq.lean"),
|
||||
read(&s.dir, "out2/Generated/approval_mq.lean")
|
||||
);
|
||||
assert_eq!(read(&s.dir, "out1/plan.json"), read(&s.dir, "out2/plan.json"));
|
||||
// plan.json 里定理声明带行号锚点。
|
||||
let plan = read(&s.dir, "out1/plan.json");
|
||||
assert!(plan.contains("\"claims\":[{"), "{plan}");
|
||||
assert!(plan.contains("\"line\":16"), "{plan}");
|
||||
}
|
||||
Reference in new issue
Block a user