X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;ds=sidebyside;f=components%2Ftactics%2Fparamodulation%2Fequality.ml;h=6b3a1e0efabc8ab8271532715d6a38003ae85593;hb=54632bfcefb8f9cf2265b27196207b2786e84927;hp=2561ea56f5a587549fdc89f6fb55fc56ecc8aece;hpb=f36b907612b05a95aba0f9e96030def1609bdadb;p=helm.git diff --git a/components/tactics/paramodulation/equality.ml b/components/tactics/paramodulation/equality.ml index 2561ea56f..6b3a1e0ef 100644 --- a/components/tactics/paramodulation/equality.ml +++ b/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 @@ -223,7 +225,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 ;; @@ -336,15 +338,16 @@ let contextualize uri ty left right t = * that is used only by the base case * * 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 p) + 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 rest) + 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 -> @@ -355,12 +358,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 m = CicSubstitution.subst hole m in let ctx_c = CicSubstitution.subst hole ctx_c in - m, ctx_c + 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 @@ -373,17 +377,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 *) @@ -392,10 +396,11 @@ 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 @@ -406,24 +411,31 @@ let contextualize uri ty left right t = let ctx_d = CicSubstitution.lift 1 ctx_d in put_in_ctx ctx_d (Cic.Rel 1) in - let lty = CicSubstitution.lift 1 ty in + let lty = CicSubstitution.lift 1 ctx_ty in Cic.Lambda (Cic.Name "foo",ty,(mk_eq uri lty l r)) 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 + 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) in - aux uri ty left right hole 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 ?(sym=false) lift subst p1 p2 pos l r pred = + +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 @@ -443,27 +455,17 @@ let build_proof_step ?(sym=false) lift subst p1 p2 pos l r pred = 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 - if sym then - let uri,pl,pr = - let eq,_,pl,pr = open_eq body in - LibraryObjects.sym_eq_URI ~eq, pl, pr - in - let l = CicSubstitution.subst other pl in - let r = CicSubstitution.subst other pr in - mk_sym uri ty l r p - else p ;; let parametrize_proof p l r ty = - let parameters = CicUtil.metas_of_term p -@ CicUtil.metas_of_term l -@ CicUtil.metas_of_term r -in (* ?if they are under a lambda? *) + let parameters = + CicUtil.metas_of_term p @ CicUtil.metas_of_term l @ CicUtil.metas_of_term r + in (* ?if they are under a lambda? *) let parameters = HExtlib.list_uniq (List.sort Pervasives.compare parameters) in @@ -568,7 +570,10 @@ let rec find_deps m i = | Step (_,(_,id1,(_,id2),_)) -> let m = find_deps m id1 in let m = find_deps m id2 in - M.add i (M.find id1 m @ M.find id2 m @ [id1;id2]) m + (* 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 = @@ -589,13 +594,14 @@ let topological_sort l = | Some ll -> Some (List.filter (fun i -> not (List.mem i l)) ll)) m in - let rec aux m = + let rec aux m res = let keys = keys m in let ok = split keys m in let m = purge ok m in - ok @ (if ok = [] then [] else aux m) + let res = ok @ res in + if ok = [] then res else aux m res in - aux m + aux m [] ;; @@ -632,10 +638,11 @@ let get_duplicate_step_in_wfo l p = (* 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 - topological_sort (List.map (fun (i,_) -> i) proofs) + let res = topological_sort (List.map (fun (i,_) -> i) proofs) in + res ;; -let build_proof_term h lift proof = +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 @@ -656,7 +663,7 @@ let build_proof_term h lift proof = | Cic.Lambda (_,a,b) -> Cic.Lambda (varname,a,b) | _ -> assert false in - let p = build_proof_step lift subst p1 p2 pos l r pred 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); @@ -666,18 +673,17 @@ let build_proof_term h lift proof = aux proof ;; -let build_goal_proof l initial ty se = +let build_goal_proof eq l initial ty se = 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 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 h n p 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 @@ -690,7 +696,7 @@ let build_goal_proof l initial ty se = | [] -> current_proof,se | (rule,pos,id,subst,pred)::tl -> let p,l,r = proof_of_id id in - let p = build_proof_term h letsno p 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 @@ -704,13 +710,13 @@ let build_goal_proof l initial ty se = | _ -> assert false in let proof = - build_proof_step letsno subst current_proof p pos l r pred + 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 h letsno initial) l + aux se (build_proof_term eq h letsno initial) l in let n,proof = let initial = proof in @@ -722,22 +728,36 @@ let build_goal_proof l initial ty se = cic, p)) lets (letsno-1,initial) in - canonical (contextualize_rewrites proof (CicSubstitution.lift letsno ty)), - se + canonical (contextualize_rewrites proof (CicSubstitution.lift letsno ty)), + se ;; -let refl_proof ty term = - Cic.Appl - [Cic.MutConstruct - (LibraryObjects.eq_URI (), 0, 1, []); - ty; term] +let refl_proof eq_uri ty term = + Cic.Appl [Cic.MutConstruct (eq_uri, 0, 1, []); ty; term] ;; let metas_of_proof p = - let p = build_proof_term [] 0 p in + 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 @@ -752,10 +772,10 @@ let relocate newmeta menv to_be_relocated = let menv = Subst.apply_subst_metasenv subst menv @ newmetasenv in subst, menv, newmeta - let fix_metas newmeta eq = let w, p, (ty, left, right, o), menv,_ = open_equality eq 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)) @@ -780,6 +800,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 @@ -903,17 +924,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 @@ -936,13 +956,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 @@ -979,3 +999,47 @@ let symmetric eq_ty l id uri m = (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" +;;