From 9576188a2e71e2d8abb0474db4037b6b35923964 Mon Sep 17 00:00:00 2001 From: cflmy Date: Mon, 16 Nov 2026 16:50:35 +0800 Subject: [PATCH] prove: real Lean 4.35.0 verification round - MarqdoProof semantic base (Val + mq* helpers + branch-contradiction lemmas, no axiom/opaque), lake-built; sources under doc/verification/ - emitter: ASCII-only namespaces (uXXXX encoding), guillemet wrapping for all non-ASCII identifiers, ':' -> '_' inside op ctor names, ctor pattern arg binding, ASCII-safe rename forms, placeholder ctor via op_ctor, flipped run equation (outputs on the left), try-split for branchless bodies, validated proof script (simp_all + .elim contradiction + omega) - business example: 3/3 theorems proved by real Lean; 5/6 claim fixtures proved, p2_len honestly unproved (false claim) - design doc section 12: Lean round findings + results --- doc/design/prove-cli.md | 34 ++++ doc/verification/skill-proof/MarqdoProof.lean | 176 ++++++++++++++++++ doc/verification/skill-proof/README.md | 49 +++++ doc/verification/skill-proof/lakefile.toml | 6 + src/prove/emit.rs | 164 +++++++++------- tests/prove.rs | 32 ++-- 6 files changed, 382 insertions(+), 79 deletions(-) create mode 100644 doc/verification/skill-proof/MarqdoProof.lean create mode 100644 doc/verification/skill-proof/README.md create mode 100644 doc/verification/skill-proof/lakefile.toml diff --git a/doc/design/prove-cli.md b/doc/design/prove-cli.md index 9c3bdfb..ac2d39a 100644 --- a/doc/design/prove-cli.md +++ b/doc/design/prove-cli.md @@ -791,3 +791,37 @@ pub fn audit_path(path: &Path) -> Result; // 不判定 - `审批.mq.md`(审批单 + 人工审核)+ `风控.mq.md`(风险分级)+ `lib/工单.mq.md`(建单):三条定理(大额必经人工 / 恰两步轨迹 / 必有回执)提取成功 - 真实解释器三场景交叉验证:5000 元 → `auto`(1 步轨迹);20000/60000 元 → 人工建单 `T-20000`/`T-60000`(`需人工 → 创建` 恰两步)——与定理表逐条吻合 - 负例:破坏定理表(未知符号 + 重复 id + 谓词元数错)→ `check --proof` 各报一码且默认关静默;emit 仍 advisory 可用;双次 emit 字节一致 + +### Lean 环境实装与真机证明(2026-11-16,Lean 4.35.0 / lake 5.0.0) + +工具链:`lean-4.35.0-linux.tar.zst` 解包至 `target/toolchain/lean-4.35.0-linux/`(无 elan, +直接 PATH);语义底座 `MarqdoProof`(`Val` + `mq*` 辅助 + 矛盾引理,无 `axiom`/`opaque`) +经 lake 构建于 `target/proof/skill-proof/`(库源同步在 `doc/verification/skill-proof/`, +发布时装入 `verification/skill-proof/`——checkout 中该目录属 root)。 + +实测发现并修正的发射器缺陷(均有测试覆盖): + +| 缺陷 | Lean 行为 | 修复 | +|---|---|---| +| `namespace Generated.审批_mq` | `namespace` 命令只接受 ASCII 名(`namespace 审批` 直接语法错误) | 非 ASCII 字符确定性编码 `uXXXX`:`Generated.u5BA1u6279_mq` | +| 裸中文标识符 `def 审批单`、`(h_前提 : …)`、`v_结果` | Lean 标识符仅 ASCII,全部语法错误 | 非 ASCII 一律 guillemet `«…»`;改名形式走同一编码(`v_u7ED3u679C`) | +| Op 构造器 `«调用:人工审核»` | guillemet 记号内 `:` 截断记号 | 标识符内 `:` → `_`;`Op.name` 字符串显示保持原 id | +| 多参构造器模式 `.«调用:x» =>` | 模式未绑定实参,类型不匹配 | `Op.name` 臂补 `_ _` | +| 占位构造器裸中文 `无操作` | 语法错误 | 占位构造器也走 `op_ctor` | +| `h_run : … = (结果, 轨迹)` 反向等式 | simp_all 不做反向替换,输出值进不了目标 | 定理陈述翻转:`((结果, 轨迹) = run env [] …)` | +| 分支互斥假设(`mqGt=true ∧ mqLe=true`) | simp_all 不链式应用蕴含引理 | 库中矛盾引理 + 脚本显式 `.elim`(`exact (mqGt_mqLe_false ‹…› ‹…›).elim`) | +| 无分支函数上 `split at h_run` | 硬报错(无 if/match 可拆),挡住本可证明的平凡断言 | `try split at h_run` | + +驱动脚本 `target/proof/run-lean-check.sh`(P1 第 2 周 `--require-lean` 集成雏形): +prove 生成 → `lake env lean` → `proved / unproved / lean-error` 三态分类。 + +真机证明结果: + +| 目标 | 结果 | +|---|---| +| 业务样例 `审批.mq.md`(3 定理:大额必经人工 / 恰两步轨迹 / 必有回执) | `lake env lean` 0 error,全部 **proved** | +| 6 个带定理的测试夹具(p1_theorem / a_deterministic / d_opaque_op / f_continuation / p2_arity / p2_len) | 5 个 **proved**;`p2_len`(计数器)如实 **unproved**——其断言 `长度(轨迹) = 2` 为假命题(函数零操作,轨迹恒空),Lean 拒绝即正确行为 | +| 全量 Rust 测试 | 499 通过;仅剩 2 个已记录的环境受限失败(python3 缺失 / playwright root 属主),与 prove 改动无关 | + +诚实性核对:`p2_len` 的 unproved 正是"绝不 lean 无法证明的 marqdo 可以证明"的落实—— +生成侧把语法合法但语义为假的断言如实交给 Lean,判定侧不会虚报 proved。 diff --git a/doc/verification/skill-proof/MarqdoProof.lean b/doc/verification/skill-proof/MarqdoProof.lean new file mode 100644 index 0000000..e2ae92a --- /dev/null +++ b/doc/verification/skill-proof/MarqdoProof.lean @@ -0,0 +1,176 @@ +/- +MarqdoProof:`marqdo prove` 生成代码的语义底座(设计 §6.2,无公理)。 + +原则: +- `Val` 是 Marqdo 值的忠实模型;每个 `mq*` 辅助函数对应 Marqdo 运行时语义的一个片段。 +- 不出现 `axiom`、不出现 `opaque`:外部操作是 `Env := Op → Val` 参数(每个生成文件 + 自带 `abbrev Env := Op → Val`,因为 `Op` 构造器集合是每文件独立的)。 +- 定理陈述把"信任了什么"写清楚:对任意 `env` 成立的命题,只依赖这里给出的方程。 +-/ + +namespace MarqdoProof + +/-- Marqdo 值模型(§6.2;`text` 是发射器的真实命名,设计文档起草时的 `str` 已修订)。 -/ +inductive Val where + | none : Val + | int : Int → Val + | num : Float → Val + | bool : Bool → Val + | text : String → Val + | list : List Val → Val + | map : List (String × Val) → Val + deriving Repr, BEq + +/-- 定理命题包装:`Bool` 语义上的"为真"。 -/ +def mqTruth (b : Bool) : Prop := b = true + +/-- 映射字段读取(`结果.ok` 等);缺失字段 → `none`(与运行时 access 一致)。 +按表项递归, simp 方程友好(`mqAccess (mqResultOk v) "ok"` 直接化到 `.bool true`)。 -/ +def mqAccess : Val → String → Val + | .map [], _ => .none + | .map ((k, v) :: rest), k' => if k == k' then v else mqAccess (.map rest) k' + | _, _ => .none + +-- ---------------------------------------------------------------- 算术 + +/-- `+`:仅 int 参与算术;其它形状 → `none`(定型检查在源语言侧拒绝混合算术)。 -/ +def mqAdd : Val → Val → Val + | .int a, .int b => .int (a + b) + | _, _ => .none + +def mqSub : Val → Val → Val + | .int a, .int b => .int (a - b) + | _, _ => .none + +def mqMul : Val → Val → Val + | .int a, .int b => .int (a * b) + | _, _ => .none + +/-- 整除;除以 0 在 Marqdo 运行时是运行时错误,此处 P1 模型按 Int 语义取 0。 -/ +def mqDiv : Val → Val → Val + | .int a, .int b => .int (a / b) + | _, _ => .none + +def mqNeg : Val → Val + | .int a => .int (-a) + | _ => .none + +-- ---------------------------------------------------------------- 比较 + +def mqLt : Val → Val → Bool + | .int a, .int b => a < b + | _, _ => false + +def mqLe : Val → Val → Bool + | .int a, .int b => a ≤ b + | _, _ => false + +def mqGt : Val → Val → Bool + | .int a, .int b => a > b + | _, _ => false + +def mqGe : Val → Val → Bool + | .int a, .int b => a ≥ b + | _, _ => false + +/-- 结构化相等(生成定理的 simp 用方程逐构造器化简)。 -/ +def mqEq : Val → Val → Bool + | .none, .none => true + | .int a, .int b => a == b + | .num a, .num b => a == b + | .bool a, .bool b => a == b + | .text a, .text b => a == b + | .list a, .list b => a == b + | .map a, .map b => a == b + | _, _ => false + +@[simp] theorem mqGt_int (a b : Int) : mqGt (Val.int a) (Val.int b) = decide (a > b) := rfl +@[simp] theorem mqGe_int (a b : Int) : mqGe (Val.int a) (Val.int b) = decide (a ≥ b) := rfl +@[simp] theorem mqLt_int (a b : Int) : mqLt (Val.int a) (Val.int b) = decide (a < b) := rfl +@[simp] theorem mqLe_int (a b : Int) : mqLe (Val.int a) (Val.int b) = decide (a ≤ b) := rfl +@[simp] theorem mqEq_int (a b : Int) : mqEq (Val.int a) (Val.int b) = decide (a = b) := rfl +@[simp] theorem mqEq_bool (a b : Bool) : mqEq (Val.bool a) (Val.bool b) = (a == b) := rfl +@[simp] theorem mqEq_text (a b : String) : mqEq (Val.text a) (Val.text b) = (a == b) := rfl + +-- ---------------------------------------------------------------- 分支矛盾 + +/-- 同一值对同一阈值既 `> n` 又 `≤ n`:分支矛盾(simp_all 消掉互斥分支)。 -/ +@[simp] theorem mqGt_mqLe_false {v : Val} {n : Int} + (h1 : mqGt v (Val.int n) = true) (h2 : mqLe v (Val.int n) = true) : False := by + cases v with + | int x => + simp only [mqGt, mqLe, decide_eq_true_eq] at h1 h2 + omega + | _ => simp [mqGt] at h1 + +@[simp] theorem mqLe_mqGt_false {v : Val} {n : Int} + (h1 : mqLe v (Val.int n) = true) (h2 : mqGt v (Val.int n) = true) : False := by + cases v with + | int x => + simp only [mqLe, mqGt, decide_eq_true_eq] at h1 h2 + omega + | _ => simp [mqGt] at h2 + +@[simp] theorem mqLt_mqGe_false {v : Val} {n : Int} + (h1 : mqLt v (Val.int n) = true) (h2 : mqGe v (Val.int n) = true) : False := by + cases v with + | int x => + simp only [mqLt, mqGe, decide_eq_true_eq] at h1 h2 + omega + | _ => simp [mqLt] at h1 + +@[simp] theorem mqGe_mqLt_false {v : Val} {n : Int} + (h1 : mqGe v (Val.int n) = true) (h2 : mqLt v (Val.int n) = true) : False := by + cases v with + | int x => + simp only [mqGe, mqLt, decide_eq_true_eq] at h1 h2 + omega + | _ => simp [mqLt] at h2 + +-- ---------------------------------------------------------------- 布尔 + +def mqAnd (a b : Bool) : Bool := a && b +def mqOr (a b : Bool) : Bool := a || b +def mqNot (b : Bool) : Bool := !b + +-- ---------------------------------------------------------------- 列表 + +/-- Val 列表的 `包含`(谓词;轨迹上的包含由生成文件按 `Op.name` 内联)。 -/ +def mqContains (xs v : Val) : Bool := + match xs with + | .list ys => ys.contains v + | _ => false + +/-- Val 列表的长度(`Val.int` 面)。 -/ +def mqLen : Val → Val + | .list ys => .int ys.length + | _ => .none + +/-- 从 `Val.int` 取 `Nat`(供 `长度` 比较等)。 -/ +def mqNatOf : Val → Nat + | .int n => n.toNat + | _ => 0 + +/-- Val 列表拼接。 -/ +def mqAppend : Val → Val → Val + | .list a, .list b => .list (a ++ b) + | _, _ => .none + +-- ---------------------------------------------------------------- lib/result + +/-- `result.ok(v)`:Val 字面映射构造(§12 偏差 2)。 -/ +def mqResultOk (v : Val) : Val := + .map [("ok", .bool true), ("value", v), ("error", .none)] + +/-- `result.error(code, message, operation)`。 -/ +def mqResultError (code message operation : Val) : Val := + .map [("ok", .bool false), ("value", .none), + ("error", .map [("code", code), ("message", message), ("operation", operation)])] + +/-- `result.value_or(r, dflt)`。 -/ +def mqValueOr (r dflt : Val) : Val := + match mqAccess r "ok" with + | .bool true => mqAccess r "value" + | _ => dflt + +end MarqdoProof diff --git a/doc/verification/skill-proof/README.md b/doc/verification/skill-proof/README.md new file mode 100644 index 0000000..7be4e64 --- /dev/null +++ b/doc/verification/skill-proof/README.md @@ -0,0 +1,49 @@ +# MarqdoProof — `marqdo prove` 生成代码的语义底座 + +`MarqdoProof.lean` 是生成 Lean 定理所依赖的全部符号(`Val`、`mq*` 辅助函数、 +矛盾引理),无公理、无 `opaque`。发布/校验环境把它作为 lake 项目 +`verification/skill-proof/` 安装(仓库 checkout 中该目录属 root,构建期 +落在 `target/proof/skill-proof/`,两者内容一致)。 + +## 构建与校验(Lean 4.35.0) + +```sh +export PATH=/bin:$PATH # lean 4.35.0 + lake 5.0.0 +cd verification/skill-proof +lake build # 产出 MarqdoProof.olean +lake env lean .lean # exit 0 且无 error ⇒ 该文件全部定理成立 +``` + +## 生成文件的形状(emit.rs 契约) + +- 命名空间强制 ASCII:`审批.mq.md` → `namespace Generated.u5BA1u6279_mq` + (Lean 的 `namespace` 命令只接受 ASCII 名字)。 +- 非 ASCII 标识符一律 guillemet:`def «审批单»`;guillemet 内 `:` 替换为 `_` + (`«调用_人工审核»`)。`Op.name` 的字符串显示保持原始 id。 +- 定理形如: + ```lean + theorem «审批单.大额必经人工» (env : Env) («金额» : Val) («等级» : Val) + («h_前提» : mqTruth (mqGt «金额» (Val.int 10000))) : + ∀ («结果» : Val) («轨迹» : List Op), + ((«结果», «轨迹») = «审批单» env [] «金额» «等级») → + mqTruth ((«轨迹».map Op.name).contains "人工审核") := by + intro «结果» «轨迹» h_run + unfold «审批单» at h_run + try split at h_run + all_goals + simp_all [mqTruth, Op.name, mqAccess, mqResultOk, mqEq] + try + first + | exact (mqGt_mqLe_false ‹mqGt _ (Val.int _) = true› ‹mqLe _ (Val.int _) = true›).elim + | … + | omega + ``` +- run 等式方向 `(结果, 轨迹) = run env [] …`:输出变量在左,simp_all 才能把 + 输出替换进目标;run 从空轨迹起跑(§2:轨迹是语法产物,函数入口为空)。 + +## 实测结论(2026-11-16,Lean 4.35.0 / lake 5.0.0) + +- 业务样例(审批.mq.md,3 条定理):`lake env lean` 0 error,全部证明。 +- 10 个测试夹具生成文件:9 个 0 error;`p2_len`(计数器)的 + `长度(轨迹) = 2` 为**假命题**(该函数不产生操作,轨迹恒空)——Lean 如实 + 未证,符合"绝不 lean 无法证明的 marqdo 可以证明"。 diff --git a/doc/verification/skill-proof/lakefile.toml b/doc/verification/skill-proof/lakefile.toml new file mode 100644 index 0000000..25f4ec3 --- /dev/null +++ b/doc/verification/skill-proof/lakefile.toml @@ -0,0 +1,6 @@ +name = "skill-proof" +version = "0.1.0" +defaultTargets = ["MarqdoProof"] + +[[lean_lib]] +name = "MarqdoProof" diff --git a/src/prove/emit.rs b/src/prove/emit.rs index 16e82fe..cd23035 100644 --- a/src/prove/emit.rs +++ b/src/prove/emit.rs @@ -50,8 +50,9 @@ fn emit_theorems(out: &mut String, fun: &FnPlan) { return; } let fun_name = lean_ident(&fun.name); - // 定理形参:`env 轨迹₀` + 函数形参。 - let mut binders = String::from("(env : Env) (轨迹₀ : List Op)"); + // 定理形参:`env` + 函数形参(Lean 标识符仅 ASCII,中文名入 guillemet)。 + // run 从空轨迹起跑(§2:轨迹是语法产物,函数入口为空)。 + let mut binders = String::from("(env : Env)"); for param in &fun.params { let _ = write!(binders, " ({} : Val)", lean_ident(¶m.name)); } @@ -72,31 +73,47 @@ fn emit_theorems(out: &mut String, fun: &FnPlan) { .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})"), + (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 run_args = fun + .params + .iter() + .map(|p| lean_ident(&p.name)) + .collect::>() + .join(" "); let _ = writeln!(out, "theorem {theorem_name} {binders}{premise_text} :"); + let _ = writeln!(out, " ∀ («结果» : Val) («轨迹» : List Op),"); + // 等式方向:`(结果, 轨迹) = run …`(输出变量在左,simp_all 才能把 + // 输出值替换进目标;反向等式 simp 不会替换)。 let _ = writeln!( out, - " ∀ (结果 : Val) (轨迹 : List Op)," + " ((«结果», «轨迹») = {fun_name} env [] {run_args}) →" ); - let _ = writeln!( - out, - " ({fun_name} env 轨迹₀ {} = (结果, 轨迹)) →", - fun.params - .iter() - .map(|p| lean_ident(&p.name)) - .collect::>() - .join(" ") - ); - let _ = writeln!(out, " {conclusion} := by"); - let _ = writeln!(out, " intro 结果 轨迹 h_run"); + let _ = writeln!(out, " mqTruth {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"); + // 每个分支:simp_all(完整默认集处理 List.map/contains/length 的 + // 结构化消去;等式替换输出;Op.name 方程化简)+ 附加域定义 + // (mqAccess/mqResultOk/mqEq 字段与构造)。互斥比较假设由库中 + // @[simp] 矛盾引理消掉,剩余线性算术交给 omega。 + let _ = writeln!( + out, + " try split at h_run + all_goals + simp_all [mqTruth, Op.name, mqAccess, mqResultOk, mqEq] + try + first + | exact (mqGt_mqLe_false ‹mqGt _ (Val.int _) = true› ‹mqLe _ (Val.int _) = true›).elim + | exact (mqLe_mqGt_false ‹mqLe _ (Val.int _) = true› ‹mqGt _ (Val.int _) = true›).elim + | exact (mqLt_mqGe_false ‹mqLt _ (Val.int _) = true› ‹mqGe _ (Val.int _) = true›).elim + | exact (mqGe_mqLt_false ‹mqGe _ (Val.int _) = true› ‹mqLt _ (Val.int _) = true›).elim + | omega" + ); } _ => { let _ = writeln!( @@ -108,12 +125,16 @@ fn emit_theorems(out: &mut String, fun: &FnPlan) { } } -/// 命名空间:文件名的安全标识符(保留 unicode 字母;不安全字符 → `_`)。 +/// 命名空间:文件名的安全标识符。Lean 4 的 `namespace` 命令**只接受 ASCII** +/// 名字(实测 `namespace 审批` 报 "expected token"),所以非 ASCII 字符 +/// 确定性编码为 `uXXXX`(码点十六进制),保证同名文件 → 同名空间。 pub fn namespace_of(stem: &str) -> String { let mut out = String::new(); for ch in stem.chars() { - if ch.is_alphanumeric() || ch == '_' { + if ch.is_ascii_alphanumeric() || ch == '_' { out.push(ch); + } else if !ch.is_ascii() { + out.push_str(&format!("u{:04X}", ch as u32)); } else { out.push('_'); } @@ -127,7 +148,8 @@ pub fn namespace_of(stem: &str) -> String { out } -/// Lean 保留字与本模块保留名(含点/空格的用 `«…»`;关键字加前缀)。 +/// Lean 保留字(`def 审批` 这类裸中文名在 Lean 里是语法错误—— +/// 标识符仅 ASCII;非 ASCII 名一律进 guillemet `«…»`)。 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", @@ -135,26 +157,31 @@ const LEAN_KEYWORDS: &[&str] = &[ ]; fn lean_ident(name: &str) -> String { - if LEAN_KEYWORDS.contains(&name) - || name == "env" - || name == "轨迹" - || name == "结果" - || name == "轨迹₀" - || name == "h_前提" - { - 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()) - { + let ascii_safe = !name.is_empty() + && name.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') + && !name.chars().next().is_some_and(|c| c.is_ascii_digit()); + if LEAN_KEYWORDS.contains(&name) || name == "env" { + // 关键字与本模块保留名(函数体里用户变量撞名时改名)。 + // 改名形式必须纯 ASCII(裸 `v_结果` 仍是 Lean 语法错误)。 + format!("v_{}", namespace_of(name)) + } else if name == "轨迹" || name == "结果" || name == "h_前提" { + // 定理作用域保留名:函数体里的用户变量/形参撞名 → v_ 前缀 + // (定理的 ∀ 绑定名由 emit_theorems/claim_term 直接写 `«…»`,不走这里)。 + format!("v_{}", namespace_of(name)) + } else if ascii_safe { name.to_string() } else { - format!("«{name}»") + // 中文名/含点/含特殊字符 → guillemet;`:` 会截断记号,替换为 `_`。 + format!("«{}»", name.replace(':', "_")) } } fn op_ctor(op_id: &str) -> String { - // `调用:人工审核` → `«调用:人工审核»`(guillemet 标识符)。 - format!("«{op_id}»") + // `调用:人工审核` → `«调用_人工审核»`(guillemet 标识符)。 + // Lean 的 guillemet 记号不接受 `:`(会截断记号),标识符里替换为 `_`; + // Op.name 的**字符串显示**保持原始 id,轨迹名不变。 + let safe = op_id.replace(':', "_"); + format!("«{safe}»") } fn emit_op_inductive(out: &mut String, plan: &Plan) { @@ -169,10 +196,11 @@ fn emit_op_inductive(out: &mut String, plan: &Plan) { } if ops.is_empty() { let _ = writeln!(out, "inductive Op where"); - let _ = writeln!(out, " | 无操作 deriving Repr, BEq"); + // 占位构造器也走 op_ctor(裸中文构造器是 Lean 语法错误)。 + let _ = writeln!(out, " | {} deriving Repr, BEq", op_ctor("无操作")); let _ = writeln!(out); let _ = writeln!(out, "def Op.name : Op → String"); - let _ = writeln!(out, " | .无操作 => \"\""); + let _ = writeln!(out, " | .{} => \"\"", op_ctor("无操作")); return; } let _ = writeln!(out, "inductive Op where"); @@ -180,7 +208,7 @@ fn emit_op_inductive(out: &mut String, plan: &Plan) { let fields = match op.arity { 0 => String::new(), n => (1..=n) - .map(|i| format!("(参数{i} : Val)")) + .map(|i| format!("(«参数{i}» : Val)")) .collect::>() .join(" "), }; @@ -191,22 +219,27 @@ fn emit_op_inductive(out: &mut String, plan: &Plan) { 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 blanks = " _".repeat(op.arity); let _ = writeln!(out, " | .{} {}=> \"{}\"", op_ctor(&op.id), blanks, label); } + let _ = writeln!(out); + // Env 依赖本文件的 Op(库无法预知),所以每文件自带: + // `env` 是"不透明操作 → 返回值"的任意函数——后置条件对一切 env 成立。 + let _ = writeln!(out, "abbrev Env := Op → Val"); } 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)"); + 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, 轨迹)"); + let _ = writeln!(out, " (Val.none, «轨迹»)"); return; } emit_seq(out, &mut String::from(" "), &[&fun.steps]); @@ -221,7 +254,7 @@ 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, 轨迹)"); + let _ = writeln!(out, "{indent}(Val.none, «轨迹»)"); } Some((first, rest)) => match first.split_first() { None => emit_seq(out, indent, rest), @@ -254,7 +287,7 @@ fn emit_step(out: &mut String, indent: &mut String, step: &Step, more: &[Step], ); let _ = writeln!( out, - "{indent}let 轨迹 := 轨迹 ++ [Op.{} {}]", + "{indent}let «轨迹» := «轨迹» ++ [Op.{} {}]", op_ctor(id), emit_args(args) ); @@ -276,7 +309,7 @@ fn emit_step(out: &mut String, indent: &mut String, step: &Step, more: &[Step], IrExpr::Op { id, args } => { let _ = writeln!( out, - "{indent}(env (Op.{} {}), 轨迹 ++ [Op.{} {}])", + "{indent}(env (Op.{} {}), «轨迹» ++ [Op.{} {}])", op_ctor(id), emit_args(args), op_ctor(id), @@ -284,7 +317,7 @@ fn emit_step(out: &mut String, indent: &mut String, step: &Step, more: &[Step], ); } other => { - let _ = writeln!(out, "{indent}({}, 轨迹)", emit_expr(other)); + let _ = writeln!(out, "{indent}({}, «轨迹»)", emit_expr(other)); } } } @@ -292,7 +325,7 @@ fn emit_step(out: &mut String, indent: &mut String, step: &Step, more: &[Step], let _ = writeln!(out, "{indent}-- mq: {line}:1"); let _ = writeln!( out, - "{indent}let 轨迹 := 轨迹 ++ [Op.{} {}]", + "{indent}let «轨迹» := «轨迹» ++ [Op.{} {}]", op_ctor(op), emit_args(args) ); @@ -488,12 +521,15 @@ mod tests { #[test] fn lean_ident_keeps_chinese_and_quotes_dotted() { - assert_eq!(lean_ident("金额"), "金额"); + // Lean 标识符仅 ASCII:中文名入 guillemet。 + assert_eq!(lean_ident("金额"), "«金额»"); assert_eq!(lean_ident("审批台.审批"), "«审批台.审批»"); + // 纯 ASCII 名保持裸写。 + assert_eq!(lean_ident("x_1"), "x_1"); // 与本模块保留名冲突的变量必须改名(确定性映射)。 assert_eq!(lean_ident("env"), "v_env"); - assert_eq!(lean_ident("轨迹"), "v_轨迹"); - assert_eq!(lean_ident("结果"), "v_结果"); + assert_eq!(lean_ident("轨迹"), "v_u8F68u8FF9"); + assert_eq!(lean_ident("结果"), "v_u7ED3u679C"); assert_eq!(lean_ident("let"), "v_let"); } @@ -507,7 +543,8 @@ mod tests { #[test] fn namespace_sanitizes_unsafe_chars_deterministically() { assert_eq!(namespace_of("approval.mq"), "approval_mq"); - assert_eq!(namespace_of("示例"), "示例"); + assert_eq!(namespace_of("示例"), "u793Au4F8B"); + // 命名空间绝不含非 ASCII(Lean namespace 命令只收 ASCII)。 assert_eq!(namespace_of("1abc"), "M1abc"); assert_eq!(namespace_of(""), "M"); } @@ -571,13 +608,13 @@ mod tests { 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"); + 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}"); + assert!(out1.contains("| «调用_读盘»"), "{out1}"); // Return 直译成对(字面量自带括号,形成双重括号——合法 Lean)。 - assert!(out1.contains("((Val.int 7), 轨迹)"), "{out1}"); + assert!(out1.contains("((Val.int 7), «轨迹»)"), "{out1}"); // 溯源注释。 assert!(out1.contains("-- mq: 3:1")); // 无时间戳。 @@ -593,8 +630,9 @@ mod tests { functions: vec![], }; let (name, out) = emit_module(&plan, "空"); - assert_eq!(name, "空.lean"); - assert!(out.contains("| 无操作")); + assert_eq!(name, "u7A7A.lean"); + // 占位构造器同样 guillemet 化(裸中文构造器是 Lean 语法错误)。 + assert!(out.contains("| «无操作»")); assert!(!out.contains("«调用:")); } } @@ -632,17 +670,17 @@ fn claim_term(ast: &super::proof_check::ClaimAst) -> Option { A::Lit(CTok::Text(s)) => Some(format!("(Val.text {})", lean_string(s))), A::Lit(_) => None, A::Var(name) => { - // 定理作用域里 `结果`/`轨迹` 是 ∀ 绑定的输出名(不加 v_ 前缀); - // `根.字段` → mqAccess 字段读取;其余按标识符规则(形参等)。 + // 定理作用域里 `结果`/`轨迹` 是 ∀ 绑定的输出名(`«结果»`/`«轨迹»`, + // 不加 v_ 前缀);`根.字段` → mqAccess 字段读取;其余按标识符规则。 let (root, field) = match name.split_once('.') { Some((r, f)) => (r, Some(f)), None => (name.as_str(), None), }; let term = match (root, field) { - ("结果", Some(f)) => format!("(mqAccess 结果 {})", lean_string(f)), - ("轨迹", Some(f)) => format!("(mqAccess 轨迹 {})", lean_string(f)), - ("结果", None) => "结果".to_string(), - ("轨迹", None) => "轨迹".to_string(), + ("结果", Some(f)) => format!("(mqAccess «结果» {})", lean_string(f)), + ("轨迹", Some(f)) => format!("(mqAccess «轨迹» {})", lean_string(f)), + ("结果", None) => "«结果»".to_string(), + ("轨迹", None) => "«轨迹»".to_string(), _ => lean_ident(name), }; Some(term) @@ -653,9 +691,9 @@ fn claim_term(ast: &super::proof_check::ClaimAst) -> Option { match (name.as_str(), args.len(), on_trace) { ("包含", 2, true) => { let item = strip_val_text(&claim_term(&args[1])?); - Some(format!("((轨迹.map Op.name).contains {item})")) + Some(format!("((«轨迹».map Op.name).contains {item})")) } - ("长度", 1, true) => Some("(轨迹.length : Nat)".to_string()), + ("长度", 1, true) => Some("(«轨迹».length : Nat)".to_string()), _ => { let mut rendered = Vec::with_capacity(args.len()); for arg in args { @@ -678,7 +716,7 @@ fn claim_term(ast: &super::proof_check::ClaimAst) -> Option { if is_trace_len(left) || is_trace_len(right) { let nat = |a: &A| -> Option { if is_trace_len(a) { - Some("(轨迹.length : Nat)".to_string()) + Some("(«轨迹».length : Nat)".to_string()) } else if let A::Lit(CTok::Int(i)) = a { Some(i.to_string()) } else { diff --git a/tests/prove.rs b/tests/prove.rs index b29b426..6174af7 100644 --- a/tests/prove.rs +++ b/tests/prove.rs @@ -274,9 +274,9 @@ fn p0_d_side_effect_import_is_opaque_op() { 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"); + 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"); @@ -314,13 +314,13 @@ fn p0_f_branch_continuation_not_swallowed() { let lean = read(&s.dir, "out/Generated/box_mq.lean"); // 分支后的 return 必须出现在两个臂里(回归:此前续延被分支吞掉)。 assert_eq!( - lean.matches("(输出, 轨迹)").count(), + 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}"); + assert!(lean.contains("let «输出» := (Val.text \"正\")"), "{lean}"); + assert!(lean.contains("let «输出» := (Val.text \"负\")"), "{lean}"); } #[test] @@ -484,16 +484,16 @@ fn p1_b_emit_theorem_scaffold() { "{lean}" ); // 前提进绑定;包含(轨迹, …) 翻成操作名成员测试。 - assert!(lean.contains("(h_前提 : mqTruth (mqGt 金额 (Val.int 10000)))"), "{lean}"); + assert!(lean.contains("(«h_前提» : mqTruth (mqGt «金额» (Val.int 10000)))"), "{lean}"); assert!( - lean.contains("((轨迹.map Op.name).contains \"人工审核\")"), + lean.contains("((«轨迹».map Op.name).contains \"人工审核\")"), "{lean}" ); // 结果.ok → mqAccess 字段读取。 - assert!(lean.contains("(mqAccess 结果 \"ok\")"), "{lean}"); + 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}"); + assert!(lean.contains("split at h_run\n all_goals\n simp_all [mqTruth, Op.name, mqAccess, mqResultOk, mqEq]"), "{lean}"); } /// check --proof(默认关):不传 --proof 时定理问题不报。 @@ -746,16 +746,16 @@ markup: occlusion let lean = read(&s.dir, "out/Generated/machine_mq.lean"); // 两个构造器,元数各自正确。 assert!( - lean.contains("| «调用:自身.加一» (参数1 : Val)"), + lean.contains("| «调用_自身.加一» («参数1» : Val)"), "{lean}" ); assert!( - lean.contains("| «调用:自身.加一/2» (参数1 : Val) (参数2 : Val)"), + lean.contains("| «调用_自身.加一/2» («参数1» : Val) («参数2» : Val)"), "{lean}" ); // 使用点各自带对个数的实参。 - assert!(lean.contains("Op.«调用:自身.加一» a)"), "{lean}"); - assert!(lean.contains("Op.«调用:自身.加一/2» a b)"), "{lean}"); + assert!(lean.contains("Op.«调用_自身.加一» a)"), "{lean}"); + assert!(lean.contains("Op.«调用_自身.加一/2» a b)"), "{lean}"); } /// 缺陷 3:`长度(轨迹) = 2` 必须生成 Nat 比较,不是 mqEq(Nat≠Val)。 @@ -790,10 +790,10 @@ import: assert_eq!(r.code, 0, "stderr={}", r.stderr); let lean = read(&s.dir, "out/Generated/count_mq.lean"); assert!( - lean.contains("((轨迹.length : Nat) = 2)"), + lean.contains("((«轨迹».length : Nat) = 2)"), "Nat 比较:{lean}" ); - assert!(!lean.contains("mqEq (轨迹.length"), "不许出现类型不匹配:{lean}"); + assert!(!lean.contains("mqEq («轨迹».length"), "不许出现类型不匹配:{lean}"); } /// 缺陷 4:谓词名遮蔽整个模块只报一次;无关函数的形参不误报。