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
This commit is contained in:
cflmy committed 2026-11-18 10:28:18 +08:00
1 parent 528a1f0dbc
commit 9576188a2e
6 files changed
+382 -79

No files matched your search

+34
View File
@@ -791,3 +791,37 @@ pub fn audit_path(path: &Path) -> Result<AuditReport>; // 不判定
- `审批.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。
@@ -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
+49
View File
@@ -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=<lean-toolchain>/bin:$PATH # lean 4.35.0 + lake 5.0.0
cd verification/skill-proof
lake build # 产出 MarqdoProof.olean
lake env lean <generated>.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 可以证明"。
@@ -0,0 +1,6 @@
name = "skill-proof"
version = "0.1.0"
defaultTargets = ["MarqdoProof"]
[[lean_lib]]
name = "MarqdoProof"
+101 -63
View File
@@ -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(&param.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::<Vec<_>>()
.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::<Vec<_>>()
.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::<Vec<_>>()
.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(&param.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<String> {
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<String> {
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<String> {
if is_trace_len(left) || is_trace_len(right) {
let nat = |a: &A| -> Option<String> {
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 {
+16 -16
View File
@@ -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:谓词名遮蔽整个模块只报一次;无关函数的形参不误报。