diff --git a/src/knowledge/projection.rs b/src/knowledge/projection.rs new file mode 100644 index 0000000..1fe322a --- /dev/null +++ b/src/knowledge/projection.rs @@ -0,0 +1,274 @@ +//! Cross-module projection contracts for the *abstract* Lean Int model. +//! +//! This is a source-regenerated, kernel-replayed proof: the callee returns +//! exactly one of its own arguments and the caller forwards one static import. +//! No arithmetic, dynamic dispatch, effects, exceptions or runtime Number +//! equivalence is inferred. Unmodeled programs never get a certificate. +use std::{collections::BTreeSet,fs,path::Path,time::Duration}; +use anyhow::{Context,Result}; +use serde_json::{json,Value}; +use sha2::{Digest,Sha256}; +use crate::{ + ast::{CallExpr,Expr,Function,Stmt}, + prove::driver::{Toolchain,compile_import_module}, + sema::ir::{BoundCall,Compilation,SemanticArtifact} +}; + +const SCOPE:&str="number_contract_int_model_pure_forwarder_parameter_projection"; +const KIND:&str="marqdo_parameter_projection_composition"; +fn sha(bytes:&[u8])->String{format!("sha256:{:x}",Sha256::digest(bytes))} + +struct Prepared { + callee_source:String, + caller_source:String, + identity:String, + result_label:String, + parameter_index:usize, +} +fn lookup<'a>(functions:&'a [Function],segments:&[&str])->Option<&'a Function>{ + let (head,tail)=segments.split_first()?; + let found=functions.iter().find(|f|f.name==*head)?; + if tail.is_empty(){Some(found)}else{lookup(&found.children,tail)} +} +fn load_function(compiled:&Compilation,artifact:&SemanticArtifact)->Option{ + let text=fs::read_to_string(compiled.semantics.root.join(&artifact.source.file)).ok()?; + let parsed=crate::parse::parse_source(&text).ok()?; + lookup(&parsed.functions,&artifact.display_name.split('.').collect::>()).cloned() +} +fn unwrap_var(expr:&Expr)->Option<&str>{ + match expr{ + Expr::Var(v)=>Some(v.as_str()), + Expr::Occluded{payload:Some(inner),..}=>unwrap_var(inner), + _=>None + } +} +fn unwrap_call(expr:&Expr)->Option<&CallExpr>{ + match expr{ + Expr::Call(c)=>Some(c), + Expr::Occluded{payload:Some(inner),..}=>unwrap_call(inner), + _=>None + } +} +fn projection(fun:&Function)->Option<&str>{ + match fun.body.as_slice(){ + [Stmt::Return{value,..}]=>unwrap_var(value), + _=>None + } +} +fn forwarder(fun:&Function)->Option<&CallExpr>{ + match fun.body.as_slice(){ + [Stmt::Return{value,..}]=>unwrap_call(value), + [Stmt::Assign{name,value,..},Stmt::Return{value:Expr::Var(result),..}] + if name==result=>unwrap_call(value), + _=>None + } +} +fn exact_unconditional_claim(compiled:&Compilation,artifact:&SemanticArtifact, + expected:&str)->bool{ + artifact.symbol_id.as_ref().is_some_and(|owner| + compiled.semantics.claims.iter().filter(|c| + c.owner==*owner && + c.premise.as_deref().map_or(true,|p|p.trim().is_empty()) && + c.conclusion.trim()==expected + ).count()==1) +} +fn candidate(compiled:&Compilation,call:&BoundCall)->Option{ + let sem=&compiled.semantics; + let ca=sem.artifacts.iter().find(|a| + a.kind=="function"&&a.symbol_id.as_ref()==Some(&call.caller))?; + let ce=sem.artifacts.iter().find(|a| + a.kind=="function"&&a.symbol_id.as_ref()==Some(&call.target))?; + if ca.source.file==ce.source.file||call.caller==call.target|| + !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=load_function(compiled,ca)?; + let callee=load_function(compiled,ce)?; + if caller.is_object()||callee.is_object(){return None} + let return_parameter=projection(&callee)?; + let forwarded=forwarder(&caller)?.for_evaluation().ok()?; + if forwarded.path.is_none()||forwarded.receiver.is_some()|| + crate::sema::bind::call_display(&forwarded)!=call.call_site || + sem.bound_calls.iter().filter(|c|c.caller==call.caller).count()!=1{ + 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()|| + forwarded.args.len()!=call.args.len(){return None} + // Canonical "number" includes non-integer variants at runtime. + // Our result is exclusively about the mathematical Int abstraction. + if cs.params.iter().chain(es.params.iter()) + .any(|p|!p.ty.eq_ignore_ascii_case("number")||!p.required|| + p.default_digest.is_some()){return None} + if !cs.params.iter().zip(caller.params.iter()) + .all(|(a,b)|a.name==b.name) || + !es.params.iter().zip(callee.params.iter()) + .all(|(a,b)|a.name==b.name){return None} + let k=es.params.iter().position(|p|p.name==return_parameter)?; + if es.params.iter().filter(|p|p.name==return_parameter).count()!=1{ + return None + } + if !exact_unconditional_claim(compiled,ce, + &format!("结果 = {return_parameter}")){return None} + let mut args=Vec::new(); + let mut caller_result=None; + for (i,(formal,arg)) in es.params.iter().zip(call.args.iter()).enumerate(){ + if arg.name.as_ref().is_some_and(|name|name!=&formal.name){return None} + let (term,label)=if let Some(value)=arg.integer{ + (format!("({value} : Int)"),value.to_string()) + }else{ + let symbol=arg.symbol.as_ref()?; + let index=cs.params.iter().position(|p|p.name==*symbol)?; + if cs.params.iter().filter(|p|p.name==*symbol).count()!=1{return None} + (format!("v{index}"),symbol.clone()) + }; + args.push(term); + if i==k{caller_result=Some(label)} + } + let result_label=caller_result?; + if !exact_unconditional_claim(compiled,ca, + &format!("结果 = {result_label}")){return None} + let callee_binders=(0..es.params.len()) + .map(|i|format!("(v{i} : Int)")).collect::>().join(" "); + let caller_binders=(0..cs.params.len()) + .map(|i|format!("(v{i} : Int)")).collect::>().join(" "); + let callee_vars=(0..es.params.len()) + .map(|i|format!("v{i}")).collect::>().join(" "); + let caller_vars=(0..cs.params.len()) + .map(|i|format!("v{i}")).collect::>().join(" "); + let call_terms=args.join(" "); + let projected_term=&args[k]; + // No author-controlled identifiers appear in generated Lean code. + let callee_source=format!( + "def callee {callee_binders} : Int := v{k}\n\ + theorem callee_contract {callee_binders} : callee {callee_vars} = v{k} := by rfl\n"); + let caller_source=format!( + "import CalleeModule\n\ + def caller {caller_binders} : Int := callee {call_terms}\n\ + theorem caller_contract {caller_binders} : caller {caller_vars} = {projected_term} := by\n\ + \x20\x20simpa [caller] using (callee_contract {call_terms})\n"); + Some(Prepared{ + callee_source,caller_source, + identity:format!("{}#{}",ca.artifact_id.0,ce.artifact_id.0), + result_label,parameter_index:k + }) +} +pub(super) fn eligible(compiled:&Compilation,call:&BoundCall)->bool{ + candidate(compiled,call).is_some() +} +fn closures(compiled:&Compilation,call:&BoundCall)->Result>{ + let set=compiled.semantics.artifacts.iter() + .filter(|a|a.symbol_id.as_ref()==Some(&call.caller)|| + a.symbol_id.as_ref()==Some(&call.target)) + .map(|a|(a.artifact_id.0.clone(),a.hashes.closure.0.clone())) + .collect::>(); + anyhow::ensure!(set.len()==2,"proof.projection_ambiguous_dependency"); + Ok(set) +} +pub(super) fn prove(compiled:&Compilation,out:&Path,lean:&Toolchain)->Result>{ + let mut rows=Vec::new(); + for call in &compiled.semantics.bound_calls{ + let Some(plan)=candidate(compiled,call) else{continue}; + let dependencies=closures(compiled,call)?; + let key=sha(format!("{}|{:?}|{}",plan.identity,dependencies,lean.version).as_bytes()); + let dir=out.join("composed").join(format!("projection-{}",&key[7..23])); + fs::create_dir_all(&dir)?; + let callee=dir.join("CalleeModule.lean"); + let caller=dir.join("CallerModule.lean"); + let callee_obj=dir.join("CalleeModule.olean"); + let caller_obj=dir.join("CallerModule.olean"); + fs::write(&callee,&plan.callee_source)?; + fs::write(&caller,&plan.caller_source)?; + let checked=(||->Result<()>{ + compile_import_module(lean,&callee,&callee_obj,&dir, + Duration::from_secs(120)).context("projection callee")?; + compile_import_module(lean,&caller,&caller_obj,&dir, + Duration::from_secs(120)).context("projection caller")?; + Ok(()) + })(); + if let Err(e)=checked{ + let _=fs::remove_file(dir.join("composition-certificate.json")); + rows.push(json!({"identity":plan.identity,"status":"lean_rejected", + "scope":SCOPE,"error":format!("{e:#}")})); + continue + } + let cert=json!({ + "schema_version":1,"kind":KIND,"scope":SCOPE, + "status":"lean_kernel_proved_model", + "identity":plan.identity, + "caller":call.caller.as_str(),"callee":call.target.as_str(), + "result_label":plan.result_label, + "parameter_index":plan.parameter_index, + "callee_source_sha256":sha(plan.callee_source.as_bytes()), + "caller_source_sha256":sha(plan.caller_source.as_bytes()), + "callee_compiled_sha256":sha(&fs::read(&callee_obj)?), + "caller_compiled_sha256":sha(&fs::read(&caller_obj)?), + "toolchain":lean.version, + "source_closures":dependencies.iter().map(|(id,closure)| + json!({"id":id,"closure":closure})).collect::>(), + "runtime_domain_verified":false, + "independent_replay":"CalleeModule.lean then CallerModule.lean" + }); + let receipt=dir.join("composition-certificate.json"); + fs::write(&receipt,serde_json::to_vec_pretty(&cert)?)?; + rows.push(json!({"identity":plan.identity,"status":"lean_kernel_proved_model", + "artifact":receipt,"scope":SCOPE})); + } + Ok(rows) +} +pub(super) fn replay(compiled:&Compilation,certificate:&Path,lean:&Toolchain) + ->Result{ + let cert:Value=serde_json::from_slice(&fs::read(certificate)?)?; + anyhow::ensure!(cert["schema_version"]==1&&cert["kind"]==KIND&& + cert["scope"]==SCOPE&&cert["status"]=="lean_kernel_proved_model", + "proof.projection_invalid_certificate"); + anyhow::ensure!(cert["toolchain"]==lean.version, + "proof.projection_stale_toolchain"); + let identity=cert["identity"].as_str().context("missing identity")?; + let matches=compiled.semantics.bound_calls.iter().filter_map(|call| + candidate(compiled,call).and_then(|p| + (p.identity==identity).then_some((call,p)))).collect::>(); + anyhow::ensure!(matches.len()==1, + "proof.projection_ambiguous_or_stale_source"); + let (call,plan)=&matches[0]; + anyhow::ensure!(cert["caller"]==call.caller.as_str()&& + cert["callee"]==call.target.as_str()&& + cert["parameter_index"]==plan.parameter_index&& + cert["result_label"]==plan.result_label, + "proof.projection_changed_proof_subject"); + let expected=closures(compiled,call)?; + let rows=cert["source_closures"].as_array() + .context("proof.projection_missing_closures")?; + let actual=rows.iter().map(|r|Ok(( + r["id"].as_str().context("proof.projection_bad_id")?.to_string(), + r["closure"].as_str().context("proof.projection_bad_closure")?.to_string() + ))).collect::>>()?; + anyhow::ensure!(rows.len()==expected.len()&&actual==expected, + "proof.projection_stale_or_ambiguous_closure"); + let dir=certificate.parent().context("missing certificate parent")?; + let callee=dir.join("CalleeModule.lean"); + let caller=dir.join("CallerModule.lean"); + anyhow::ensure!(fs::read_to_string(&callee)?==plan.callee_source&& + fs::read_to_string(&caller)?==plan.caller_source&& + cert["callee_source_sha256"]==sha(plan.callee_source.as_bytes())&& + cert["caller_source_sha256"]==sha(plan.caller_source.as_bytes()), + "proof.projection_generated_source_mismatch"); + let callee_obj=dir.join("CalleeModule.olean"); + let caller_obj=dir.join("CallerModule.olean"); + compile_import_module(lean,&callee,&callee_obj,dir, + Duration::from_secs(120))?; + compile_import_module(lean,&caller,&caller_obj,dir, + Duration::from_secs(120))?; + anyhow::ensure!(cert["callee_compiled_sha256"]==sha(&fs::read(callee_obj)?)&& + cert["caller_compiled_sha256"]==sha(&fs::read(caller_obj)?), + "proof.projection_replay_output_changed"); + Ok(json!({"schema_version":1,"kind":"independent_composition_replay", + "status":"lean_kernel_replayed","scope":SCOPE,"identity":identity, + "current_source_verified":true, + "full_marqdo_runtime_semantics_proved":false})) +}