X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fsoftware%2Fcomponents%2Ftactics%2Fparamodulation%2Fequality.ml;h=4414d2f435f3af14a1d8cc1d32c131bd0b241db7;hb=b0bbbe6ec20a0afa145c1e6d92530105d9d4d7e3;hp=b921f78c1984bfed44701c202e20deede6d77ecd;hpb=5b911ecf8bcb1644b82316d5f2709ae253a6a36d;p=helm.git diff --git a/helm/software/components/tactics/paramodulation/equality.ml b/helm/software/components/tactics/paramodulation/equality.ml index b921f78c1..4414d2f43 100644 --- a/helm/software/components/tactics/paramodulation/equality.ml +++ b/helm/software/components/tactics/paramodulation/equality.ml @@ -23,6 +23,8 @@ * http://cs.unibo.it/helm/. *) +let _profiler = <:profiler<_profiler>>;; + (* $Id: inference.ml 6245 2006-04-05 12:07:51Z tassi $ *) type rule = SuperpositionRight | SuperpositionLeft | Demodulation @@ -41,9 +43,11 @@ and proof = | Exact of Cic.term | Step of Subst.substitution * (rule * int*(Utils.pos*int)* Cic.term) (* subst, (rule,eq1, eq2,predicate) *) -and goal_proof = (Utils.pos * int * Subst.substitution * Cic.term) list +and goal_proof = (rule * Utils.pos * int * Subst.substitution * Cic.term) list ;; +type goal = goal_proof * Cic.metasenv * Cic.term + (* globals *) let maxid = ref 0;; let id_to_eq = Hashtbl.create 1024;; @@ -75,21 +79,29 @@ let mk_tmp_equality (weight,(ty,l,r,o),m) = let open_equality (_,weight,proof,(ty,l,r,o),m,id) = (weight,proof,(ty,l,r,o),m,id) +let string_of_rule = function + | SuperpositionRight -> "SupR" + | SuperpositionLeft -> "SupL" + | Demodulation -> "Demod" +;; + let string_of_equality ?env eq = match env with | None -> - let w, _, (ty, left, right, o), _ , id = open_equality eq in - Printf.sprintf "Id: %d, Weight: %d, {%s}: %s =(%s) %s" + let w, _, (ty, left, right, o), m , id = open_equality eq in + Printf.sprintf "Id: %d, Weight: %d, {%s}: %s =(%s) %s [%s]" id w (CicPp.ppterm ty) (CicPp.ppterm left) (Utils.string_of_comparison o) (CicPp.ppterm right) + (String.concat ", " (List.map (fun (i,_,_) -> string_of_int i) m)) | Some (_, context, _) -> let names = Utils.names_of_context context in - let w, _, (ty, left, right, o), _ , id = open_equality eq in - Printf.sprintf "Id: %d, Weight: %d, {%s}: %s =(%s) %s" + let w, _, (ty, left, right, o), m , id = open_equality eq in + Printf.sprintf "Id: %d, Weight: %d, {%s}: %s =(%s) %s [%s]" id w (CicPp.pp ty names) (CicPp.pp left names) (Utils.string_of_comparison o) (CicPp.pp right names) + (String.concat ", " (List.map (fun (i,_,_) -> string_of_int i) m)) ;; let compare (_,_,_,s1,_,_) (_,_,_,s2,_,_) = @@ -105,11 +117,6 @@ let proof_of_id id = let string_of_proof ?(names=[]) p gp = - let str_of_rule = function - | SuperpositionRight -> "SupR" - | SuperpositionLeft -> "SupL" - | Demodulation -> "Demod" - in let str_of_pos = function | Utils.Left -> "left" | Utils.Right -> "right" @@ -122,7 +129,7 @@ let string_of_proof ?(names=[]) p gp = prefix (CicPp.pp t names) | Step (subst,(rule,eq1,(pos,eq2),pred)) -> Printf.sprintf "%s%s(%s|%d with %d dir %s pred %s))\n" - prefix (str_of_rule rule) (Subst.ppsubst ~names subst) eq1 eq2 (str_of_pos pos) + prefix (string_of_rule rule) (Subst.ppsubst ~names subst) eq1 eq2 (str_of_pos pos) (CicPp.pp pred names)^ aux (margin+1) (Printf.sprintf "%d" eq1) (fst3 (proof_of_id eq1)) ^ aux (margin+1) (Printf.sprintf "%d" eq2) (fst3 (proof_of_id eq2)) @@ -130,25 +137,34 @@ let string_of_proof ?(names=[]) p gp = aux 0 "" p ^ String.concat "\n" (List.map - (fun (pos,i,s,t) -> + (fun (r,pos,i,s,t) -> (Printf.sprintf - "GOAL: %s %d %s %s\n" + "GOAL: %s %s %d %s %s\n" (string_of_rule r) (str_of_pos pos) i (Subst.ppsubst ~names s) (CicPp.pp t names)) ^ aux 1 (Printf.sprintf "%d " i) (fst3 (proof_of_id i))) gp) ;; -let rec depend eq id = +let rec depend eq id seen = let (_,p,(_,_,_,_),_,ideq) = open_equality eq in - if id = ideq then true else - match p with - Exact _ -> false - | Step (_,(_,id1,(_,id2),_)) -> - let eq1 = Hashtbl.find id_to_eq id1 in - let eq2 = Hashtbl.find id_to_eq id2 in - depend eq1 id || depend eq2 id2 + if List.mem ideq seen then + false,seen + else + if id = ideq then + true,seen + else + match p with + | Exact _ -> false,seen + | Step (_,(_,id1,(_,id2),_)) -> + let seen = ideq::seen in + let eq1 = Hashtbl.find id_to_eq id1 in + let eq2 = Hashtbl.find id_to_eq id2 in + let b1,seen = depend eq1 id seen in + if b1 then b1,seen else depend eq2 id seen ;; +let depend eq id = fst (depend eq id []);; + let ppsubst = Subst.ppsubst ~names:[];; (* returns an explicit named subst and a list of arguments for sym_eq_URI *) @@ -196,6 +212,13 @@ let open_trans ens tl = | _ -> assert false ;; +let open_sym ens tl = + let args = List.map snd ens @ tl in + match args with + | [ty;l;r;p] -> ty,l,r,p + | _ -> assert false +;; + let open_eq_ind args = match args with | [ty;l;pred;pl;r;pleqr] -> ty,l,pred,pl,r,pleqr @@ -204,7 +227,7 @@ let open_eq_ind args = let open_pred pred = match pred with - | Cic.Lambda (_,ty,(Cic.Appl [Cic.MutInd (uri, 0,_);_;l;r])) + | Cic.Lambda (_,_,(Cic.Appl [Cic.MutInd (uri, 0,_);ty;l;r])) when LibraryObjects.is_eq_URI uri -> ty,uri,l,r | _ -> prerr_endline (CicPp.ppterm pred); assert false ;; @@ -214,8 +237,35 @@ let is_not_fixed t = CicSubstitution.subst (Cic.Rel 1) t ;; +let head_of_apply = function | Cic.Appl (hd::_) -> hd | t -> t;; +let tail_of_apply = function | Cic.Appl (_::tl) -> tl | t -> [];; +let count_args t = List.length (tail_of_apply t);; +let rec build_nat = + let u = UriManager.uri_of_string "cic:/matita/nat/nat/nat.ind" in + function + | 0 -> Cic.MutConstruct(u,0,1,[]) + | n -> + Cic.Appl [Cic.MutConstruct(u,0,2,[]);build_nat (n-1)] +;; +let tyof context menv t = + try + fst(CicTypeChecker.type_of_aux' menv context t CicUniv.empty_ugraph) + with + | CicTypeChecker.TypeCheckerFailure _ + | CicTypeChecker.AssertFailure _ -> assert false +;; +let rec lambdaof left context = function + | Cic.Prod (n,s,t) -> + Cic.Lambda (n,s,lambdaof left context t) + | Cic.Appl [Cic.MutInd (uri, 0,_);ty;l;r] + when LibraryObjects.is_eq_URI uri -> if left then l else r + | t -> + let names = Utils.names_of_context context in + prerr_endline ("lambdaof: " ^ (CicPp.pp t names)); + assert false +;; -let canonical t = +let canonical t context menv = let rec remove_refl t = match t with | Cic.Appl (((Cic.Const(uri_trans,ens))::tl) as args) @@ -228,22 +278,58 @@ let canonical t = remove_refl p1 | _ -> Cic.Appl (List.map remove_refl args)) | Cic.Appl l -> Cic.Appl (List.map remove_refl l) + | Cic.LetIn (name,bo,rest) -> + Cic.LetIn (name,remove_refl bo,remove_refl rest) | _ -> t in - let rec canonical t = + let rec canonical context t = match t with + | Cic.LetIn(name,bo,rest) -> + let context' = (Some (name,Cic.Def (bo,None)))::context in + Cic.LetIn(name,canonical context bo,canonical context' rest) | Cic.Appl (((Cic.Const(uri_sym,ens))::tl) as args) when LibraryObjects.is_sym_eq_URI uri_sym -> (match p_of_sym ens tl with | Cic.Appl ((Cic.Const(uri,ens))::tl) when LibraryObjects.is_sym_eq_URI uri -> - canonical (p_of_sym ens tl) + canonical context (p_of_sym ens tl) | Cic.Appl ((Cic.Const(uri_trans,ens))::tl) when LibraryObjects.is_trans_eq_URI uri_trans -> let ty,l,m,r,p1,p2 = open_trans ens tl in mk_trans uri_trans ty r m l - (canonical (mk_sym uri_sym ty m r p2)) - (canonical (mk_sym uri_sym ty l m p1)) + (canonical context (mk_sym uri_sym ty m r p2)) + (canonical context (mk_sym uri_sym ty l m p1)) + | Cic.Appl (([Cic.Const(uri_feq,ens);ty1;ty2;f;x;y;p])) -> + + let eq_f_sym = + Cic.Const (UriManager.uri_of_string + "cic:/matita/logic/equality/eq_f1.con",[]) + in + Cic.Appl (([eq_f_sym;ty1;ty2;f;x;y;p])) + +(* + let sym_eq = Cic.Const(uri_sym,ens) in + let eq_f = Cic.Const(uri_feq,[]) in + let b = Cic.MutConstruct (UriManager.uri_of_string + "cic:/matita/datatypes/bool/bool.ind",0,1,[]) + in + let u = ty1 in + let ctx = f in + let n = build_nat (count_args p) in + let h = head_of_apply p in + let predl = lambdaof true context (tyof context menv h) in + let predr = lambdaof false context (tyof context menv h) in + let args = tail_of_apply p in + let appl = + Cic.Appl + ([Cic.Const(UriManager.uri_of_string + "cic:/matita/paramodulation/rewrite.con",[]); + eq; sym_eq; eq_f; b; u; ctx; n; predl; predr; h] @ + args) + in + appl +*) +(* | Cic.Appl (((Cic.Const(uri_ind,ens)) as he)::tl) when LibraryObjects.is_eq_ind_URI uri_ind || LibraryObjects.is_eq_ind_r_URI uri_ind -> @@ -267,13 +353,14 @@ let canonical t = Cic.Appl [he;ty;what;pred; canonical (mk_sym uri_sym ty l r p1);other;canonical p2] +*) | Cic.Appl [Cic.MutConstruct (uri, 0, 1,_);_;_] as t when LibraryObjects.is_eq_URI uri -> t - | _ -> Cic.Appl (List.map canonical args)) - | Cic.Appl l -> Cic.Appl (List.map canonical l) + | _ -> Cic.Appl (List.map (canonical context) args)) + | Cic.Appl l -> Cic.Appl (List.map (canonical context) l) | _ -> t in - remove_refl (canonical t) + remove_refl (canonical context t) ;; let ty_of_lambda = function @@ -283,12 +370,12 @@ let ty_of_lambda = function let compose_contexts ctx1 ctx2 = ProofEngineReduction.replace_lifting - ~equality:(=) ~what:[Cic.Rel 1] ~with_what:[ctx2] ~where:ctx1 + ~equality:(=) ~what:[Cic.Implicit(Some `Hole)] ~with_what:[ctx2] ~where:ctx1 ;; let put_in_ctx ctx t = ProofEngineReduction.replace_lifting - ~equality:(=) ~what:[Cic.Rel 1] ~with_what:[t] ~where:ctx + ~equality:(=) ~what:[Cic.Implicit (Some `Hole)] ~with_what:[t] ~where:ctx ;; let mk_eq uri ty l r = @@ -305,16 +392,29 @@ let open_eq = function | _ -> assert false ;; +let mk_feq uri_feq ty ty1 left pred right t = + Cic.Appl [Cic.Const(uri_feq,[]);ty;ty1;pred;left;right;t] +;; + let contextualize uri ty left right t = + let hole = Cic.Implicit (Some `Hole) in (* aux [uri] [ty] [left] [right] [ctx] [t] * * the parameters validate this invariant * t: eq(uri) ty left right * that is used only by the base case * - * ctx is a term with an open (Rel 1). (Rel 1) is the empty context + * ctx is a term with an hole. Cic.Implicit(Some `Hole) is the empty context + * ty_ctx is the type of ctx_d *) - let rec aux uri ty left right ctx_d = function + let rec aux uri ty left right ctx_d ctx_ty = function + | Cic.Appl ((Cic.Const(uri_sym,ens))::tl) + when LibraryObjects.is_sym_eq_URI uri_sym -> + let ty,l,r,p = open_sym ens tl in + mk_sym uri_sym ty l r (aux uri ty l r ctx_d ctx_ty p) + | Cic.LetIn (name,body,rest) -> + (* we should go in body *) + Cic.LetIn (name,body,aux uri ty left right ctx_d ctx_ty rest) | Cic.Appl ((Cic.Const(uri_ind,ens))::tl) when LibraryObjects.is_eq_ind_URI uri_ind || LibraryObjects.is_eq_ind_r_URI uri_ind -> @@ -325,12 +425,13 @@ let contextualize uri ty left right t = let is_not_fixed_lp = is_not_fixed lp in let avoid_eq_ind = LibraryObjects.is_eq_ind_URI uri_ind in (* extract the context and the fixed term from the predicate *) - let m, ctx_c = + let m, ctx_c, ty2 = let m, ctx_c = if is_not_fixed_lp then rp,lp else lp,rp in (* they were under a lambda *) - let m = CicSubstitution.subst (Cic.Implicit None) m in - let ctx_c = CicSubstitution.subst (Cic.Rel 1) ctx_c in - m, ctx_c + let m = CicSubstitution.subst hole m in + let ctx_c = CicSubstitution.subst hole ctx_c in + let ty2 = CicSubstitution.subst hole ty2 in + m, ctx_c, ty2 in (* create the compound context and put the terms under it *) let ctx_dc = compose_contexts ctx_d ctx_c in @@ -343,17 +444,17 @@ let contextualize uri ty left right t = (* now put the proofs in the compound context *) let p1 = (* p1: dc_what = d_m *) if is_not_fixed_lp then - aux uri ty1 c_what m ctx_d p1 + aux uri ty2 c_what m ctx_d ctx_ty p1 else - mk_sym uri_sym ty d_m dc_what - (aux uri ty1 m c_what ctx_d p1) + mk_sym uri_sym ctx_ty d_m dc_what + (aux uri ty2 m c_what ctx_d ctx_ty p1) in let p2 = (* p2: dc_other = dc_what *) if avoid_eq_ind then - mk_sym uri_sym ty dc_what dc_other - (aux uri ty1 what other ctx_dc p2) + mk_sym uri_sym ctx_ty dc_what dc_other + (aux uri ty1 what other ctx_dc ctx_ty p2) else - aux uri ty1 other what ctx_dc p2 + aux uri ty1 other what ctx_dc ctx_ty p2 in (* if pred = \x.C[x]=m --> t : C[other]=m --> trans other what m if pred = \x.m=C[x] --> t : m=C[other] --> trans m what other *) @@ -362,42 +463,58 @@ let contextualize uri ty left right t = dc_other,dc_what,d_m,p2,p1 else d_m,dc_what,dc_other, - (mk_sym uri_sym ty dc_what d_m p1), - (mk_sym uri_sym ty dc_other dc_what p2) + (mk_sym uri_sym ctx_ty dc_what d_m p1), + (mk_sym uri_sym ctx_ty dc_other dc_what p2) in - mk_trans uri_trans ty a b c paeqb pbeqc + mk_trans uri_trans ctx_ty a b c paeqb pbeqc + | t when ctx_d = hole -> t | t -> - let uri_sym = LibraryObjects.sym_eq_URI ~eq:uri in - let uri_ind = LibraryObjects.eq_ind_URI ~eq:uri in +(* let uri_sym = LibraryObjects.sym_eq_URI ~eq:uri in *) +(* let uri_ind = LibraryObjects.eq_ind_URI ~eq:uri in *) + let uri_feq = + UriManager.uri_of_string "cic:/matita/logic/equality/eq_f.con" + in let pred = - (* ctx_d will go under a lambda, but put_in_ctx substitutes Rel 1 *) - let ctx_d = CicSubstitution.lift_from 2 1 ctx_d in (* bleah *) - let r = put_in_ctx ctx_d (CicSubstitution.lift 1 left) in - let l = ctx_d in - let lty = CicSubstitution.lift 1 ty in - Cic.Lambda (Cic.Name "foo",ty,(mk_eq uri lty l r)) +(* let r = CicSubstitution.lift 1 (put_in_ctx ctx_d left) in *) + let l = + let ctx_d = CicSubstitution.lift 1 ctx_d in + put_in_ctx ctx_d (Cic.Rel 1) + in +(* let lty = CicSubstitution.lift 1 ctx_ty in *) +(* Cic.Lambda (Cic.Name "foo",ty,(mk_eq uri lty l r)) *) + Cic.Lambda (Cic.Name "foo",ty,l) in - let d_left = put_in_ctx ctx_d left in - let d_right = put_in_ctx ctx_d right in - let refl_eq = mk_refl uri ty d_left in - mk_sym uri_sym ty d_right d_left - (mk_eq_ind uri_ind ty left pred refl_eq right t) +(* let d_left = put_in_ctx ctx_d left in *) +(* let d_right = put_in_ctx ctx_d right in *) +(* let refl_eq = mk_refl uri ctx_ty d_left in *) +(* mk_sym uri_sym ctx_ty d_right d_left *) +(* (mk_eq_ind uri_ind ty left pred refl_eq right t) *) + (mk_feq uri_feq ty ctx_ty left pred right t) in - let empty_context = Cic.Rel 1 in - aux uri ty left right empty_context t + aux uri ty left right hole ty t ;; let contextualize_rewrites t ty = let eq,ty,l,r = open_eq ty in contextualize eq ty l r t ;; - -let build_proof_step subst p1 p2 pos l r pred = - let p1 = Subst.apply_subst subst p1 in - let p2 = Subst.apply_subst subst p2 in - let l = Subst.apply_subst subst l in - let r = Subst.apply_subst subst r in - let pred = Subst.apply_subst subst pred in + +let add_subst subst = + function + | Exact t -> Exact (Subst.apply_subst subst t) + | Step (s,(rule, id1, (pos,id2), pred)) -> + Step (Subst.concat subst s,(rule, id1, (pos,id2), pred)) +;; + +let build_proof_step eq lift subst p1 p2 pos l r pred = + let p1 = Subst.apply_subst_lift lift subst p1 in + let p2 = Subst.apply_subst_lift lift subst p2 in + let l = CicSubstitution.lift lift l in + let l = Subst.apply_subst_lift lift subst l in + let r = CicSubstitution.lift lift r in + let r = Subst.apply_subst_lift lift subst r in + let pred = CicSubstitution.lift lift pred in + let pred = Subst.apply_subst_lift lift subst pred in let ty,body = match pred with | Cic.Lambda (_,ty,body) -> ty,body @@ -406,27 +523,56 @@ let build_proof_step subst p1 p2 pos l r pred = let what, other = if pos = Utils.Left then l,r else r,l in + let p = match pos with | Utils.Left -> - mk_eq_ind (Utils.eq_ind_URI ()) ty what pred p1 other p2 + mk_eq_ind (LibraryObjects.eq_ind_URI ~eq) ty what pred p1 other p2 | Utils.Right -> - mk_eq_ind (Utils.eq_ind_r_URI ()) ty what pred p1 other p2 + mk_eq_ind (LibraryObjects.eq_ind_r_URI ~eq) ty what pred p1 other p2 + in + p ;; -let build_proof_term proof = - let rec aux = function - | Exact term -> term - | Step (subst,(_, id1, (pos,id2), pred)) -> - let p,_,_ = proof_of_id id1 in - let p1 = aux p in - let p,l,r = proof_of_id id2 in - let p2 = aux p in - build_proof_step subst p1 p2 pos l r pred +let parametrize_proof p l r ty = + let uniq l = HExtlib.list_uniq (List.sort Pervasives.compare l) in + let mot = CicUtil.metas_of_term_set in + let parameters = uniq (mot p @ mot l @ mot r) in + (* ?if they are under a lambda? *) + let parameters = + HExtlib.list_uniq (List.sort Pervasives.compare parameters) in - aux proof + let what = List.map (fun (i,l) -> Cic.Meta (i,l)) parameters in + let with_what, lift_no = + List.fold_right (fun _ (acc,n) -> ((Cic.Rel n)::acc),n+1) what ([],1) + in + let p = CicSubstitution.lift (lift_no-1) p in + let p = + ProofEngineReduction.replace_lifting + ~equality:(fun t1 t2 -> + match t1,t2 with Cic.Meta (i,_),Cic.Meta(j,_) -> i=j | _ -> false) + ~what ~with_what ~where:p + in + let ty_of_m _ = ty (*function + | Cic.Meta (i,_) -> List.assoc i menv + | _ -> assert false *) + in + let args, proof,_ = + List.fold_left + (fun (instance,p,n) m -> + (instance@[m], + Cic.Lambda + (Cic.Name ("x"^string_of_int n), + CicSubstitution.lift (lift_no - n - 1) (ty_of_m m), + p), + n+1)) + ([Cic.Rel 1],p,1) + what + in + let instance = match args with | [x] -> x | _ -> Cic.Appl args in + proof, instance ;; -let wfo goalproof proof = +let wfo goalproof proof id = let rec aux acc id = let p,_,_ = proof_of_id id in match p with @@ -438,93 +584,308 @@ let wfo goalproof proof = in let acc = match proof with - | Exact _ -> [] - | Step (_,(_,id1, (_,id2), _)) -> aux (aux [] id1) id2 + | Exact _ -> [id] + | Step (_,(_,id1, (_,id2), _)) -> aux (aux [id] id1) id2 in - List.fold_left (fun acc (_,id,_,_) -> aux acc id) acc goalproof + List.fold_left (fun acc (_,_,id,_,_) -> aux acc id) acc goalproof ;; let string_of_id names id = + if id = 0 then "" else try - let (_,p,(_,l,r,_),_,_) = open_equality (Hashtbl.find id_to_eq id) in + let (_,p,(_,l,r,_),m,_) = open_equality (Hashtbl.find id_to_eq id) in match p with | Exact t -> - Printf.sprintf "%d = %s: %s = %s" id + Printf.sprintf "%d = %s: %s = %s [%s]" id (CicPp.pp t names) (CicPp.pp l names) (CicPp.pp r names) + (String.concat ", " (List.map (fun (i,_,_) -> string_of_int i) m)) | Step (_,(step,id1, (_,id2), _) ) -> - Printf.sprintf "%6d: %s %6d %6d %s = %s" id - (if step = SuperpositionRight then "SupR" else "Demo") + Printf.sprintf "%6d: %s %6d %6d %s = %s [%s]" id + (string_of_rule step) id1 id2 (CicPp.pp l names) (CicPp.pp r names) + (String.concat ", " (List.map (fun (i,_,_) -> string_of_int i) m)) with Not_found -> assert false -let pp_proof names goalproof proof = - String.concat "\n" (List.map (string_of_id names) (wfo goalproof proof)) ^ - "\ngoal is demodulated with " ^ - (String.concat " " - ((List.map (fun (_,i,_,_) -> string_of_int i) goalproof))) +let pp_proof names goalproof proof subst id initial_goal = + String.concat "\n" (List.map (string_of_id names) (wfo goalproof proof id)) ^ + "\ngoal:\n " ^ + (String.concat "\n " + (fst (List.fold_right + (fun (r,pos,i,s,pred) (acc,g) -> + let _,_,left,right = open_eq g in + let ty = + match pos with + | Utils.Left -> CicReduction.head_beta_reduce (Cic.Appl[pred;right]) + | Utils.Right -> CicReduction.head_beta_reduce (Cic.Appl[pred;left]) + in + let ty = Subst.apply_subst s ty in + ("("^ string_of_rule r ^ " " ^ string_of_int i^") -> " + ^ CicPp.pp ty names) :: acc,ty) goalproof ([],initial_goal)))) ^ + "\nand then subsumed by " ^ string_of_int id ^ " when " ^ Subst.ppsubst subst ;; -let build_goal_proof l initial ty = - let proof = - List.fold_left - (fun current_proof (pos,id,subst,pred) -> - let p,l,r = proof_of_id id in - let p = build_proof_term p in - let pos = if pos = Utils.Left then Utils.Right else Utils.Left in - build_proof_step subst current_proof p pos l r pred) - initial l +module OT = + struct + type t = int + let compare = Pervasives.compare + end + +module M = Map.Make(OT) + +let rec find_deps m i = + if M.mem i m then m + else + let p,_,_ = proof_of_id i in + match p with + | Exact _ -> M.add i [] m + | Step (_,(_,id1,(_,id2),_)) -> + let m = find_deps m id1 in + let m = find_deps m id2 in + (* without the uniq there is a stack overflow doing concatenation *) + let xxx = [id1;id2] @ M.find id1 m @ M.find id2 m in + let xxx = HExtlib.list_uniq (List.sort Pervasives.compare xxx) in + M.add i xxx m +;; + +let topological_sort l = + (* build the partial order relation *) + let m = List.fold_left (fun m i -> find_deps m i) M.empty l in + let m = (* keep only deps inside l *) + List.fold_left + (fun m' i -> + M.add i (List.filter (fun x -> List.mem x l) (M.find i m)) m') + M.empty l + in + let m = M.map (fun x -> Some x) m in + (* utils *) + let keys m = M.fold (fun i _ acc -> i::acc) m [] in + let split l m = List.filter (fun i -> M.find i m = Some []) l in + let purge l m = + M.mapi + (fun k v -> if List.mem k l then None else + match v with + | None -> None + | Some ll -> Some (List.filter (fun i -> not (List.mem i l)) ll)) + m + in + let rec aux m res = + let keys = keys m in + let ok = split keys m in + let m = purge ok m in + let res = ok @ res in + if ok = [] then res else aux m res + in + let rc = List.rev (aux m []) in + rc +;; + + +(* returns the list of ids that should be factorized *) +let get_duplicate_step_in_wfo l p = + let ol = List.rev l in + let h = Hashtbl.create 13 in + (* NOTE: here the n parameter is an approximation of the dependency + between equations. To do things seriously we should maintain a + dependency graph. This approximation is not perfect. *) + let add i = + let p,_,_ = proof_of_id i in + match p with + | Exact _ -> true + | _ -> + try + let no = Hashtbl.find h i in + Hashtbl.replace h i (no+1); + false + with Not_found -> Hashtbl.add h i 1;true + in + let rec aux = function + | Exact _ -> () + | Step (_,(_,i1,(_,i2),_)) -> + let go_on_1 = add i1 in + let go_on_2 = add i2 in + if go_on_1 then aux (let p,_,_ = proof_of_id i1 in p); + if go_on_2 then aux (let p,_,_ = proof_of_id i2 in p) in - canonical (contextualize_rewrites proof ty) + aux p; + List.iter + (fun (_,_,id,_,_) -> aux (let p,_,_ = proof_of_id id in p)) + ol; + (* now h is complete *) + let proofs = Hashtbl.fold (fun k count acc-> (k,count)::acc) h [] in + let proofs = List.filter (fun (_,c) -> c > 1) proofs in + let res = topological_sort (List.map (fun (i,_) -> i) proofs) in + res ;; -let refl_proof ty term = - Cic.Appl - [Cic.MutConstruct - (LibraryObjects.eq_URI (), 0, 1, []); - ty; term] +let build_proof_term eq h lift proof = + let proof_of_id aux id = + let p,l,r = proof_of_id id in + try List.assoc id h,l,r with Not_found -> aux p, l, r + in + let rec aux = function + | Exact term -> + CicSubstitution.lift lift term + | Step (subst,(rule, id1, (pos,id2), pred)) -> + let p1,_,_ = proof_of_id aux id1 in + let p2,l,r = proof_of_id aux id2 in + let varname = + match rule with + | SuperpositionRight -> Cic.Name ("SupR" ^ Utils.string_of_pos pos) + | Demodulation -> Cic.Name ("DemEq"^ Utils.string_of_pos pos) + | _ -> assert false + in + let pred = + match pred with + | Cic.Lambda (_,a,b) -> Cic.Lambda (varname,a,b) + | _ -> assert false + in + let p = build_proof_step eq lift subst p1 p2 pos l r pred in +(* let cond = (not (List.mem 302 (Utils.metas_of_term p)) || id1 = 8 || id1 = 132) in + if not cond then + prerr_endline ("ERROR " ^ string_of_int id1 ^ " " ^ string_of_int id2); + assert cond;*) + p + in + aux proof ;; -let metas_of_proof p = - Utils.metas_of_term (build_proof_term p) +let build_goal_proof eq l initial ty se context menv = + let se = List.map (fun i -> Cic.Meta (i,[])) se in + let lets = get_duplicate_step_in_wfo l initial in + let letsno = List.length lets in + let _,mty,_,_ = open_eq ty in + let lift_list l = List.map (fun (i,t) -> i,CicSubstitution.lift 1 t) l in + let lets,_,h = + List.fold_left + (fun (acc,n,h) id -> + let p,l,r = proof_of_id id in + let cic = build_proof_term eq h n p in + let real_cic,instance = + parametrize_proof cic l r (CicSubstitution.lift n mty) + in + let h = (id, instance)::lift_list h in + acc@[id,real_cic],n+1,h) + ([],0,[]) lets + in + let proof,se = + let rec aux se current_proof = function + | [] -> current_proof,se + | (rule,pos,id,subst,pred)::tl -> + let p,l,r = proof_of_id id in + let p = build_proof_term eq h letsno p in + let pos = if pos = Utils.Left then Utils.Right else Utils.Left in + let varname = + match rule with + | SuperpositionLeft -> Cic.Name ("SupL" ^ Utils.string_of_pos pos) + | Demodulation -> Cic.Name ("DemG"^ Utils.string_of_pos pos) + | _ -> assert false + in + let pred = + match pred with + | Cic.Lambda (_,a,b) -> Cic.Lambda (varname,a,b) + | _ -> assert false + in + let proof = + build_proof_step eq letsno subst current_proof p pos l r pred + in + let proof,se = aux se proof tl in + Subst.apply_subst_lift letsno subst proof, + List.map (fun x -> Subst.apply_subst_lift letsno subst x) se + in + aux se (build_proof_term eq h letsno initial) l + in + let n,proof = + let initial = proof in + List.fold_right + (fun (id,cic) (n,p) -> + n-1, + Cic.LetIn ( + Cic.Name ("H"^string_of_int id), + cic, p)) + lets (letsno-1,initial) + in + canonical + (contextualize_rewrites proof (CicSubstitution.lift letsno ty)) + context menv, + se +;; + +let refl_proof eq_uri ty term = + Cic.Appl [Cic.MutConstruct (eq_uri, 0, 1, []); ty; term] ;; -let relocate newmeta menv = - let subst, metasenv, newmeta = +let metas_of_proof p = + let eq = + match LibraryObjects.eq_URI () with + | Some u -> u + | None -> + raise + (ProofEngineTypes.Fail + (lazy "No default equality defined when calling metas_of_proof")) + in + let p = build_proof_term eq [] 0 p in + Utils.metas_of_term p +;; + +let remove_local_context eq = + let w, p, (ty, left, right, o), menv,id = open_equality eq in + let p = Utils.remove_local_context p in + let ty = Utils.remove_local_context ty in + let left = Utils.remove_local_context left in + let right = Utils.remove_local_context right in + w, p, (ty, left, right, o), menv, id +;; + +let relocate newmeta menv to_be_relocated = + let subst, newmetasenv, newmeta = List.fold_right - (fun (i, context, ty) (subst, menv, maxmeta) -> - let irl = [] (* - CicMkImplicit.identity_relocation_list_for_metavariable context *) - in - let newsubst = Subst.buildsubst i context (Cic.Meta(maxmeta,irl)) ty subst in - let newmeta = maxmeta, context, ty in - newsubst, newmeta::menv, maxmeta+1) - menv (Subst.empty_subst, [], newmeta+1) + (fun i (subst, metasenv, maxmeta) -> + let _,context,ty = CicUtil.lookup_meta i menv in + let irl = [] in + let newmeta = Cic.Meta(maxmeta,irl) in + let newsubst = Subst.buildsubst i context newmeta ty subst in + newsubst, (maxmeta,context,ty)::metasenv, maxmeta+1) + to_be_relocated (Subst.empty_subst, [], newmeta+1) in - let metasenv = Subst.apply_subst_metasenv subst metasenv in - let subst = Subst.flatten_subst subst in - subst, metasenv, newmeta + let menv = Subst.apply_subst_metasenv subst menv @ newmetasenv in + subst, menv, newmeta +let fix_metas_goal newmeta goal = + let (proof, menv, ty) = goal in + let to_be_relocated = + HExtlib.list_uniq (List.sort Pervasives.compare (Utils.metas_of_term ty)) + in + let subst, menv, newmeta = relocate newmeta menv to_be_relocated in + let ty = Subst.apply_subst subst ty in + let proof = + match proof with + | [] -> assert false (* is a nonsense to relocate the initial goal *) + | (r,pos,id,s,p) :: tl -> (r,pos,id,Subst.concat subst s,p) :: tl + in + newmeta+1,(proof, menv, ty) +;; let fix_metas newmeta eq = let w, p, (ty, left, right, o), menv,_ = open_equality eq in - (* debug - let _ , eq = - fix_metas_old newmeta (w, p, (ty, left, right, o), menv, args) in - prerr_endline (string_of_equality eq); *) - let subst, metasenv, newmeta = relocate newmeta menv in + let to_be_relocated = +(* List.map (fun i ,_,_ -> i) menv *) + HExtlib.list_uniq + (List.sort Pervasives.compare + (Utils.metas_of_term left @ Utils.metas_of_term right)) + in + let subst, metasenv, newmeta = relocate newmeta menv to_be_relocated in let ty = Subst.apply_subst subst ty in let left = Subst.apply_subst subst left in let right = Subst.apply_subst subst right in let fix_proof = function | Exact p -> Exact (Subst.apply_subst subst p) | Step (s,(r,id1,(pos,id2),pred)) -> - Step (Subst.concat_substs s subst,(r,id1,(pos,id2), pred)) + Step (Subst.concat s subst,(r,id1,(pos,id2), pred)) in let p = fix_proof p in - let eq = mk_equality (w, p, (ty, left, right, o), metasenv) in - (* debug prerr_endline (string_of_equality eq); *) - newmeta+1, eq + let eq' = mk_equality (w, p, (ty, left, right, o), metasenv) in + newmeta+1, eq' exception NotMetaConvertible;; @@ -533,6 +894,7 @@ let meta_convertibility_aux table t1 t2 = let rec aux ((table_l, table_r) as table) t1 t2 = match t1, t2 with | C.Meta (m1, tl1), C.Meta (m2, tl2) -> + let tl1, tl2 = [],[] in let m1_binding, table_l = try List.assoc m1 table_l, table_l with Not_found -> m2, (m1, m2)::table_l @@ -656,17 +1018,16 @@ let meta_convertibility t1 t2 = exception TermIsNotAnEquality;; let term_is_equality term = - let iseq uri = UriManager.eq uri (LibraryObjects.eq_URI ()) in match term with - | Cic.Appl [Cic.MutInd (uri, _, _); _; _; _] when iseq uri -> true + | Cic.Appl [Cic.MutInd (uri, _, _); _; _; _] + when LibraryObjects.is_eq_URI uri -> true | _ -> false ;; let equality_of_term proof term = - let eq_uri = LibraryObjects.eq_URI () in - let iseq uri = UriManager.eq uri eq_uri in match term with - | Cic.Appl [Cic.MutInd (uri, _, _); ty; t1; t2] when iseq uri -> + | Cic.Appl [Cic.MutInd (uri, _, _); ty; t1; t2] + when LibraryObjects.is_eq_URI uri -> let o = !Utils.compare_terms t1 t2 in let stat = (ty,t1,t2,o) in let w = Utils.compute_equality_weight stat in @@ -689,13 +1050,13 @@ let is_identity (_, context, ugraph) eq = ;; -let term_of_equality equality = +let term_of_equality eq_uri equality = let _, _, (ty, left, right, _), menv, _= open_equality equality in let eq i = function Cic.Meta (j, _) -> i = j | _ -> false in let argsno = List.length menv in let t = CicSubstitution.lift argsno - (Cic.Appl [Cic.MutInd (LibraryObjects.eq_URI (), 0, []); ty; left; right]) + (Cic.Appl [Cic.MutInd (eq_uri, 0, []); ty; left; right]) in snd ( List.fold_right @@ -711,3 +1072,68 @@ let term_of_equality equality = menv (argsno, t)) ;; +let symmetric eq_ty l id uri m = + let eq = Cic.MutInd(uri,0,[]) in + let pred = + Cic.Lambda (Cic.Name "Sym",eq_ty, + Cic.Appl [CicSubstitution.lift 1 eq ; + CicSubstitution.lift 1 eq_ty; + Cic.Rel 1;CicSubstitution.lift 1 l]) + in + let prefl = + Exact (Cic.Appl + [Cic.MutConstruct(uri,0,1,[]);eq_ty;l]) + in + let id1 = + let eq = mk_equality (0,prefl,(eq_ty,l,l,Utils.Eq),m) in + let (_,_,_,_,id) = open_equality eq in + id + in + Step(Subst.empty_subst, + (Demodulation,id1,(Utils.Left,id),pred)) +;; + +module IntOT = struct + type t = int + let compare = Pervasives.compare +end + +module IntSet = Set.Make(IntOT);; + +let n_purged = ref 0;; + +let collect alive1 alive2 alive3 = + let _ = <:start> in + let deps_of id = + let p,_,_ = proof_of_id id in + match p with + | Exact _ -> IntSet.empty + | Step (_,(_,id1,(_,id2),_)) -> + IntSet.add id1 (IntSet.add id2 IntSet.empty) + in + let rec close s = + let news = IntSet.fold (fun id s -> IntSet.union (deps_of id) s) s s in + if IntSet.equal news s then s else close news + in + let l_to_s s l = List.fold_left (fun s x -> IntSet.add x s) s l in + let alive_set = l_to_s (l_to_s (l_to_s IntSet.empty alive2) alive1) alive3 in + let closed_alive_set = close alive_set in + let to_purge = + Hashtbl.fold + (fun k _ s -> + if not (IntSet.mem k closed_alive_set) then + k::s else s) id_to_eq [] + in + n_purged := !n_purged + List.length to_purge; + List.iter (Hashtbl.remove id_to_eq) to_purge; + let _ = <:stop> in () +;; + +let id_of e = + let _,_,_,_,id = open_equality e in id +;; + +let get_stats () = + <:show> ^ + "# of purged eq by the collector: " ^ string_of_int !n_purged ^ "\n" +;;