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:
1 parent
528a1f0dbc
commit
9576188a2e
6 files changed
+382
-79
No files matched your search
@@ -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
|
||||
@@ -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
@@ -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::<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(¶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<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
@@ -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:谓词名遮蔽整个模块只报一次;无关函数的形参不误报。
|
||||
|
||||
Reference in new issue
Block a user