Files
marqdo/src/knowledge/composition.rs
T

388 lines
17 KiB
Rust

//! Reusable, independently replayable **restricted** module composition.
//!
//! Scope: pure typed-int forwarding caller and source-constant callee. Two
//! independently compiled Lean modules: caller imports the callee's theorem,
//! not its implementation. Every unmodeled construct fails closed.
//! This is not a theorem about arbitrary Marqdo programs.
use std::{fs,path::Path,time::Duration};
use anyhow::{Context,Result};
use serde_json::{json,Value};
use sha2::{Digest,Sha256};
use crate::{
ast::{CallExpr,Expr,Function,Literal,Stmt},
prove::driver::{Toolchain,compile_import_module},
sema::ir::{Compilation,SemanticArtifact,BoundCall}
};
fn sha(input:&[u8])->String{format!("sha256:{:x}",Sha256::digest(input))}
fn lookup<'a>(items:&'a [Function],path:&[&str])->Option<&'a Function>{
let (first,rest)=path.split_first()?;
let fun=items.iter().find(|f|f.name==*first)?;
if rest.is_empty(){Some(fun)}else{lookup(&fun.children,rest)}
}
fn function(compiled:&Compilation,a:&SemanticArtifact)->Option<Function>{
let raw=fs::read_to_string(compiled.semantics.root.join(&a.source.file)).ok()?;
let doc=crate::parse::parse_source(&raw).ok()?;
let path=a.display_name.split('.').collect::<Vec<_>>();
lookup(&doc.functions,&path).cloned()
}
fn call_inside(expr:&Expr)->Option<&CallExpr>{
match expr{
Expr::Call(c)=>Some(c),
Expr::Occluded{payload:Some(inner),..}=>call_inside(inner),
_=>None
}
}
fn forwarded(fun:&Function)->Option<&CallExpr>{
match fun.body.as_slice(){
[Stmt::Return{value,..}]=>call_inside(value),
[Stmt::Assign{name,value,..},Stmt::Return{value:Expr::Var(v),..}]
if name==v=>call_inside(value),
_=>None
}
}
fn constant_return(fun:&Function)->Option<i64>{
match fun.body.as_slice(){
[Stmt::Return{value:Expr::Literal(Literal::Int(n)),..}]=>Some(*n),
[Stmt::Return{value:Expr::Occluded{payload:Some(v),..},..}] =>
if let Expr::Literal(Literal::Int(n))=v.as_ref(){Some(*n)}else{None},
_=>None
}
}
fn claim_is_constant(compiled:&Compilation,owner:&SemanticArtifact,n:i64)->bool{
owner.symbol_id.as_ref().is_some_and(|id|
compiled.semantics.claims.iter().any(|c|
c.owner==*id
&& c.premise.as_deref().map_or(true,|p|p.trim().is_empty())
&& c.conclusion.trim()==format!("结果 = {n}")))
}
fn candidate(compiled:&Compilation,call:&BoundCall)
->Option<(String,String,String,i64)>{
let ca=compiled.semantics.artifacts.iter().find(|a|
a.symbol_id.as_ref()==Some(&call.caller) && a.kind=="function")?;
let ce=compiled.semantics.artifacts.iter().find(|a|
a.symbol_id.as_ref()==Some(&call.target) && a.kind=="function")?;
if !ca.effects.is_pure()||!ce.effects.is_pure()
||!call.required_effects.is_pure()
||call.control_blocker.is_some()||!call.path_guards.is_empty(){return None}
let caller=function(compiled,ca)?;
let callee=function(compiled,ce)?;
let forwarded=forwarded(&caller)?;
let runtime=forwarded.for_evaluation().ok()?;
if crate::sema::bind::call_display(&runtime)!=call.call_site
||compiled.semantics.bound_calls.iter().filter(|item|
item.caller==call.caller).count()!=1 {return None}
if runtime.path.as_ref().is_none()||runtime.receiver.is_some()
||caller.is_object()||callee.is_object(){return None}
let n=constant_return(&callee)?;
if !claim_is_constant(compiled,ca,n)||!claim_is_constant(compiled,ce,n){
return None
}
let cs=ca.signature.as_ref()?;
let es=ce.signature.as_ref()?;
if cs.params.len()!=caller.params.len()
||es.params.len()!=callee.params.len()
||es.params.len()!=call.args.len()
||call.args.len()!=runtime.args.len(){return None}
if cs.params.iter().chain(es.params.iter())
// Marqdo currently canonicalizes int/num/float to "number".
// This certificate is explicitly about the *Lean Int model*, NOT
// all runtime Number variants. Runtime-equivalence remains false.
.any(|p|!p.ty.eq_ignore_ascii_case("number")||!p.required){return None}
let arg_expr=call.args.iter().zip(es.params.iter()).map(|(a,p)|{
if a.name.as_ref().is_some_and(|x|x!=&p.name){return None}
if let Some(v)=a.integer {return Some(format!("({v} : Int)"))}
let symbol=a.symbol.as_ref()?;
let position=cs.params.iter().position(|x|x.name==*symbol)?;
Some(format!("v{position}"))
}).collect::<Option<Vec<_>>>()?.join(" ");
let callee_binders=(0..es.params.len()).map(|i|format!("(v{i} : Int)"))
.collect::<Vec<_>>().join(" ");
let caller_binders=(0..cs.params.len()).map(|i|format!("(v{i} : Int)"))
.collect::<Vec<_>>().join(" ");
let callee_args=(0..es.params.len()).map(|i|format!("v{i}"))
.collect::<Vec<_>>().join(" ");
let caller_args=(0..cs.params.len()).map(|i|format!("v{i}"))
.collect::<Vec<_>>().join(" ");
// This callee theorem is verified from the translated source *inside its
// own module*. The caller only imports its proved interface theorem.
let callee_src=format!(
"-- pure typed-int fragment of {}\n\
def callee {callee_binders} : Int := ({n} : Int)\n\
theorem callee_contract {callee_binders} : callee {callee_args} = ({n} : Int) := by rfl\n",
ce.artifact_id.0);
let caller_src=format!(
"import CalleeModule\n\
-- exact forwarded import call from {}\n\
def caller {caller_binders} : Int := callee {arg_expr}\n\
theorem caller_contract {caller_binders} : caller {caller_args} = ({n} : Int) := by\n\
\x20\x20simpa [caller] using (callee_contract {arg_expr})\n",
ca.artifact_id.0);
Some((callee_src,caller_src,format!("{}#{}",ca.artifact_id.0,
ce.artifact_id.0),n))
}
/// Explain why a caller cannot receive a scoped composition certificate.
/// Missing evidence is reported, never fixed up by guessing call identities.
fn rejection_diagnostics(c:&Compilation,call:&BoundCall)->Value{
let caller=c.semantics.artifacts.iter().find(|a|
a.symbol_id.as_ref()==Some(&call.caller));
let callee=c.semantics.artifacts.iter().find(|a|
a.symbol_id.as_ref()==Some(&call.target));
let cf=caller.and_then(|a|function(c,a));
let ef=callee.and_then(|a|function(c,a));
let constant=ef.as_ref().and_then(constant_return);
json!({
"caller_semantics_resolved":caller.is_some(),
"callee_semantics_resolved":callee.is_some(),
"caller_effects":caller.map(|a|a.effects.values()),
"callee_effects":callee.map(|a|a.effects.values()),
"call_effects":call.required_effects.values(),
"caller_forward_shape":cf.as_ref().and_then(forwarded).is_some(),
"caller_ast_body":cf.as_ref().map(|f|format!("{:?}",f.body)),
"callee_ast_body":ef.as_ref().map(|f|format!("{:?}",f.body)),
"callee_constant_return":constant,
"runtime_forward_name":cf.as_ref().and_then(forwarded)
.and_then(|f|f.for_evaluation().ok())
.map(|c|crate::sema::bind::call_display(&c)),
"bound_call_name":call.call_site,
"caller_bound_call_count":c.semantics.bound_calls.iter()
.filter(|item|item.caller==call.caller).count(),
"caller_has_expected_claim":caller.zip(constant).is_some_and(|(a,n)|
claim_is_constant(c,a,n)),
"callee_has_expected_claim":callee.zip(constant).is_some_and(|(a,n)|
claim_is_constant(c,a,n)),
"caller_signature":caller.and_then(|a|a.signature.as_ref())
.map(|s|s.params.iter().map(|p|json!({"name":p.name,"type":p.ty,
"required":p.required})).collect::<Vec<_>>()),
"callee_signature":callee.and_then(|a|a.signature.as_ref())
.map(|s|s.params.iter().map(|p|json!({"name":p.name,"type":p.ty,
"required":p.required})).collect::<Vec<_>>()),
"actual_arguments":call.args.iter().map(|a|json!({
"name":a.name,"symbol":a.symbol,"integer":a.integer})).collect::<Vec<_>>(),
"path_guards":call.path_guards,"control_blocker":call.control_blocker
})
}
/// Emit one sealed bundle per eligible call. An unsuccessful Lean command
/// never creates a certificate; the JSON report carries the failure.
pub fn prove(compiled:&Compilation,out:&Path,toolchain:&Toolchain)->Result<Value>{
let mut records=Vec::new();
for call in &compiled.semantics.bound_calls{
let Some((source,client,identity,n))=candidate(compiled,call) else {
records.push(json!({"caller":call.caller.as_str(),
"callee":call.target.as_str(),"status":"unsupported_fragment",
"reason":"requires_pure_number_contract_int_model_forwarder_with_constant_claims",
"diagnostics":rejection_diagnostics(compiled,call)}));
continue;
};
let key=sha(format!("{}|{}|{}|{}",identity,
compiled.semantics.artifacts.iter().find(|a|
a.symbol_id.as_ref()==Some(&call.caller))
.map(|a|a.hashes.closure.0.as_str()).unwrap_or(""),
compiled.semantics.artifacts.iter().find(|a|
a.symbol_id.as_ref()==Some(&call.target))
.map(|a|a.hashes.closure.0.as_str()).unwrap_or(""),
toolchain.version).as_bytes());
let folder=out.join("composed").join(&key[7..23]);
fs::create_dir_all(&folder)?;
let callee=folder.join("CalleeModule.lean");
let caller=folder.join("CallerModule.lean");
let built=folder.join("CalleeModule.olean");
fs::write(&callee,&source)?;
fs::write(&caller,&client)?;
let run=(|| ->Result<()>{
compile_import_module(toolchain,&callee,&built,&folder,
Duration::from_secs(120)).context("callee interface")?;
let verified=folder.join("CallerModule.olean");
compile_import_module(toolchain,&caller,&verified,&folder,
Duration::from_secs(120)).context("caller composition")?;
Ok(())
})();
if let Err(e)=run{
let _=fs::remove_file(folder.join("composition-certificate.json"));
records.push(json!({"identity":identity,
"status":"lean_rejected","error":format!("{e:#}")}));
continue
}
let cert=json!({
"schema_version":1,"kind":"marqdo_restricted_composition",
"scope":"number_contract_int_model_pure_forwarder_constant_result",
"status":"lean_kernel_proved_model",
"identity":identity,"caller":call.caller.as_str(),
"callee":call.target.as_str(),
"claimed_result":n,
"callee_source_sha256":sha(source.as_bytes()),
"caller_source_sha256":sha(client.as_bytes()),
"callee_compiled_sha256":sha(&fs::read(&built)?),
"caller_compiled_sha256":sha(&fs::read(folder.join("CallerModule.olean"))?),
"toolchain":toolchain.version,
"source_closures":compiled.semantics.artifacts.iter()
.filter(|a|a.symbol_id.as_ref()==Some(&call.caller)
||a.symbol_id.as_ref()==Some(&call.target))
.map(|a|json!({"id":a.artifact_id.0,
"closure":a.hashes.closure.0})).collect::<Vec<_>>(),
"independent_replay":"CalleeModule.lean then CallerModule.lean"
});
let receipt=folder.join("composition-certificate.json");
fs::write(&receipt,serde_json::to_vec_pretty(&cert)?)?;
records.push(json!({"identity":identity,
"status":"lean_kernel_proved_model","artifact":receipt,
"scope":"number_contract_int_model_pure_forwarder_constant_result"}));
}
Ok(json!({"schema_version":1,"role":"restricted_composed_lean_module",
"results":records,
"full_marqdo_runtime_semantics_proved":false}))
}
/// Replay a composition certificate *against the current project source*.
/// The certificate never supplies Lean source code: it must byte-match source
/// recompiled from the current Marqdo AST, and both Lean modules are rechecked.
pub fn replay(compiled:&Compilation,certificate:&Path,lean:&Toolchain)->Result<Value>{
let receipt:Value=serde_json::from_slice(&fs::read(certificate)?)?;
anyhow::ensure!(receipt["schema_version"]==1
&&receipt["kind"]=="marqdo_restricted_composition"
&&receipt["scope"]=="number_contract_int_model_pure_forwarder_constant_result"
&&receipt["status"]=="lean_kernel_proved_model",
"proof.compose_invalid_certificate: unexpected status or scope");
anyhow::ensure!(receipt["toolchain"]==lean.version,
"proof.compose_stale_toolchain");
let identity=receipt["identity"].as_str().context("missing identity")?;
let Some((callee,caller,_,n,call))=compiled.semantics.bound_calls.iter()
.filter_map(|call|{
let (a,b,id,n)=candidate(compiled,call)?;
(id==identity).then_some((a,b,id,n,call))
}).next() else {anyhow::bail!("proof.compose_stale_source: candidate missing");};
anyhow::ensure!(receipt["claimed_result"]==n,
"proof.compose_claim_changed");
anyhow::ensure!(receipt["caller"]==call.caller.as_str()
&&receipt["callee"]==call.target.as_str(),
"proof.compose_symbol_changed");
for symbol in [&call.caller,&call.target]{
let artifact=compiled.semantics.artifacts.iter()
.find(|a|a.symbol_id.as_ref()==Some(symbol))
.context("proof.compose_missing_artifact")?;
anyhow::ensure!(receipt["source_closures"].as_array()
.is_some_and(|items|items.iter().any(|r|
r["id"]==artifact.artifact_id.0
&&r["closure"]==artifact.hashes.closure.0)),
"proof.compose_stale_closure");
}
let folder=certificate.parent().context("missing certificate parent")?;
let callee_path=folder.join("CalleeModule.lean");
let caller_path=folder.join("CallerModule.lean");
anyhow::ensure!(fs::read_to_string(&callee_path)?==callee
&&fs::read_to_string(&caller_path)?==caller,
"proof.compose_generated_source_mismatch");
anyhow::ensure!(receipt["callee_source_sha256"]==sha(callee.as_bytes())
&&receipt["caller_source_sha256"]==sha(caller.as_bytes()),
"proof.compose_hash_mismatch");
let callee_obj=folder.join("CalleeModule.olean");
let caller_obj=folder.join("CallerModule.olean");
compile_import_module(lean,&callee_path,&callee_obj,folder,
Duration::from_secs(120))?;
compile_import_module(lean,&caller_path,&caller_obj,folder,
Duration::from_secs(120))?;
anyhow::ensure!(receipt["callee_compiled_sha256"]==sha(&fs::read(&callee_obj)?)
&&receipt["caller_compiled_sha256"]==sha(&fs::read(&caller_obj)?),
"proof.compose_replay_output_changed");
Ok(json!({"schema_version":1,"kind":"independent_composition_replay",
"status":"lean_kernel_replayed","scope":receipt["scope"],
"identity":identity,"current_source_verified":true,
"full_marqdo_runtime_semantics_proved":false}))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn pure_forwarder_can_be_compiled_into_two_independent_lean_sources(){
let root=std::env::temp_dir().join(
format!("marqdo-compose-unit-{}",std::process::id()));
let _=fs::remove_dir_all(&root);
fs::create_dir_all(&root).unwrap();
fs::write(root.join("math.mq.md"),r#"---
markup: occlusion
---
# math
## exact
+ `n`
| 参数 | 类型 | 说明 |
|---|---|---|
| n | int | integer |
| 定理 | 结论 | 策略 |
|---|---|---|
| fixed | 结果 = 2 | auto |
*2*
"#).unwrap();
fs::write(root.join("main.mq.md"),r#"---
markup: occlusion
import:
math: math.mq.md
---
# main
## forward
+ `n`
| 参数 | 类型 | 说明 |
|---|---|---|
| n | int | integer |
| 定理 | 结论 | 策略 |
|---|---|---|
| same | 结果 = 2 | auto |
**v = [调用](math.math.exact(`n`))**
*v*
"#).unwrap();
let c=crate::sema::ir::compile_project(
&crate::sema::ir::CompileOptions::for_path(&root).unwrap()).unwrap();
let call=c.semantics.bound_calls.iter().find(|x|
x.call_site=="math.math.exact").unwrap();
let (callee,caller,_,result)=candidate(&c,call)
.unwrap_or_else(||panic!("composition candidate rejected: {}",
rejection_diagnostics(&c,call)));
assert_eq!(result,2);
assert!(callee.contains("theorem callee_contract"));
assert!(caller.starts_with("import CalleeModule"));
assert!(caller.contains("using (callee_contract"));
// Branching is explicitly outside the certificate scope.
fs::write(root.join("main.mq.md"),r#"---
import:
math: math.mq.md
---
# main
## forward
+ `n`
| 参数 | 类型 | 说明 |
|---|---|---|
| n | int | integer |
| 定理 | 结论 | 策略 |
|---|---|---|
| same | 结果 = 2 | auto |
1. `n` > 0
**v = [调用](math.math.exact(`n`))**
2. *
**v = 0**
*v*
"#).unwrap();
let changed=crate::sema::ir::compile_project(
&crate::sema::ir::CompileOptions::for_path(&root).unwrap()).unwrap();
let guarded=changed.semantics.bound_calls.iter().find(|x|
x.call_site=="math.math.exact").unwrap();
assert!(candidate(&changed,guarded).is_none());
fs::remove_dir_all(root).unwrap();
}
}