X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fsoftware%2Fcomponents%2Ftactics%2Fparamodulation%2Fequality.ml;h=cb12f7a77c6ffbc335de5c4cf7f680dab55f5fea;hb=25564c06c570e5ab9be455904c0b381842f8d4c4;hp=1d798f9dc1a7d8b88867a5bc9fa6bb908a636405;hpb=b4da5c84ca7fa4c028ef70875aa79cc7bc279ee9;p=helm.git diff --git a/helm/software/components/tactics/paramodulation/equality.ml b/helm/software/components/tactics/paramodulation/equality.ml index 1d798f9dc..cb12f7a77 100644 --- a/helm/software/components/tactics/paramodulation/equality.ml +++ b/helm/software/components/tactics/paramodulation/equality.ml @@ -1,4 +1,4 @@ -(* cOpyright (C) 2005, HELM Team. +(* Copyright (C) 2005, HELM Team. * * This file is part of HELM, an Hypertextual, Electronic * Library of Mathematics, developed at the Computer Science @@ -47,30 +47,26 @@ and proof = and goal_proof = (rule * Utils.pos * int * Subst.substitution * Cic.term) list ;; (* the hashtbl eq_id -> proof, max_eq_id *) -type equality_bag = (int,equality) Hashtbl.t * int ref +module IntOt = struct type t = int let compare = Pervasives.compare end +module M = Map.Make(IntOt) +type equality_bag = equality M.t * int type goal = goal_proof * Cic.metasenv * Cic.term (* globals *) -let mk_equality_bag () = - Hashtbl.create 1024, ref 0 -;; +let mk_equality_bag () = M.empty, 10000 ;; -let freshid (_,i) = - incr i; !i -;; +let freshid (m,i) = (m,i+1), i+1 ;; -let add_to_bag (id_to_eq,_) id eq = - Hashtbl.add id_to_eq id eq -;; +let add_to_bag (id_to_eq,i) id eq = M.add id eq id_to_eq,i ;; let uncomparable = fun _ -> 0 let mk_equality bag (weight,p,(ty,l,r,o),m) = - let id = freshid bag in + let bag, id = freshid bag in let eq = (uncomparable,weight,p,(ty,l,r,o),m,id) in - add_to_bag bag id eq; - eq + let bag = add_to_bag bag id eq in + bag, eq ;; let mk_tmp_equality (weight,(ty,l,r,o),m) = @@ -82,6 +78,11 @@ 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 id_of e = + let _,_,_,_,id = open_equality e in id +;; + + let string_of_rule = function | SuperpositionRight -> "SupR" | SuperpositionLeft -> "SupL" @@ -96,8 +97,8 @@ let string_of_equality ?env eq = 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)) *) - "..." + (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), m , id = open_equality eq in @@ -105,8 +106,8 @@ let string_of_equality ?env eq = 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)) *) - "..." + (String.concat ", " (List.map (fun (i,_,_) -> string_of_int i) m)) +(* "..." *) ;; let compare (_,_,_,s1,_,_) (_,_,_,s2,_,_) = @@ -117,8 +118,8 @@ let rec max_weight_in_proof ((id_to_eq,_) as bag) current = function | Exact _ -> current | Step (_, (_,id1,(_,id2),_)) -> - let eq1 = Hashtbl.find id_to_eq id1 in - let eq2 = Hashtbl.find id_to_eq id2 in + let eq1 = M.find id1 id_to_eq in + let eq2 = M.find id2 id_to_eq in let (w1,p1,(_,_,_,_),_,_) = open_equality eq1 in let (w2,p2,(_,_,_,_),_,_) = open_equality eq2 in let current = max current w1 in @@ -129,7 +130,7 @@ let rec max_weight_in_proof ((id_to_eq,_) as bag) current = let max_weight_in_goal_proof ((id_to_eq,_) as bag) = List.fold_left (fun current (_,_,id,_,_) -> - let eq = Hashtbl.find id_to_eq id in + let eq = M.find id id_to_eq in let (w,p,(_,_,_,_),_,_) = open_equality eq in let current = max current w in max_weight_in_proof bag current p) @@ -140,10 +141,17 @@ let max_weight bag goal_proof proof = let proof_of_id (id_to_eq,_) id = try - let (_,p,(_,l,r,_),_,_) = open_equality (Hashtbl.find id_to_eq id) in + let (_,p,(_,l,r,_),_,_) = open_equality (M.find id id_to_eq) in p,l,r with - Not_found -> assert false + Not_found -> + prerr_endline ("Unable to find the proof of " ^ string_of_int id); + assert false +;; + +let is_in (id_to_eq,_) id = + M.mem id id_to_eq +;; let string_of_proof ?(names=[]) bag p gp = @@ -187,8 +195,8 @@ let rec depend ((id_to_eq,_) as bag) eq id seen = | 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 eq1 = M.find id1 id_to_eq in + let eq2 = M.find id2 id_to_eq in let b1,seen = depend bag eq1 id seen in if b1 then b1,seen else depend bag eq2 id seen ;; @@ -260,7 +268,7 @@ let open_pred pred = match pred with | 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 + | _ -> Utils.debug_print (lazy (CicPp.ppterm pred)); assert false ;; let is_not_fixed t = @@ -269,6 +277,48 @@ let is_not_fixed t = ;; let canonical t context menv = + let remove_cycles t = + let is_transitive = + function + Cic.Appl (Cic.Const (uri_trans,_)::_) + when LibraryObjects.is_trans_eq_URI uri_trans -> + true + | _ -> false in + let rec collect = + function + 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 + (if is_transitive p1 then fst (collect p1) else [l,p1]) @ + (if is_transitive p2 then fst (collect p2) else [m,p2]), + (r, uri_trans, ty) + | t -> assert false in + let rec cut_to_last_duplicate l acc = + function + [] -> List.rev acc + | (l',p)::tl when l=l' -> +if acc <> [] then +Utils.debug_print (lazy ("!!! RISPARMIO " ^ string_of_int (List.length acc) ^ " PASSI")); + cut_to_last_duplicate l [l',p] tl + | (l',p)::tl -> + cut_to_last_duplicate l ((l',p)::acc) tl + in + let rec rebuild = + function + (l,_)::_::_ as steps, ((r,uri_trans,ty) as last) -> + (match cut_to_last_duplicate l [] steps with + (l,p1)::((m,_)::_::_ as tl) -> + mk_trans uri_trans ty l m r p1 (rebuild (tl,last)) + | [l,p1 ; m,p2] -> mk_trans uri_trans ty l m r p1 p2 + | [l,p1] -> p1 + | [] -> assert false) + | _ -> assert false + in + if is_transitive t then + rebuild (collect t) + else + t + in let rec remove_refl t = match t with | Cic.Appl (((Cic.Const(uri_trans,ens))::tl) as args) @@ -281,15 +331,23 @@ let canonical t context menv = 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) + | Cic.LetIn (name,bo,ty,rest) -> + Cic.LetIn (name,remove_refl bo,remove_refl ty,remove_refl rest) | _ -> t in - let rec canonical context t = + let rec canonical_trough_lambda context = function + | Cic.Lambda(name,ty,bo) -> + let context' = (Some (name,Cic.Decl ty))::context in + Cic.Lambda(name,ty,canonical_trough_lambda context' bo) + | t -> canonical context t + + and 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.LetIn(name,bo,ty,rest) -> + let bo = canonical_trough_lambda context bo in + let ty = canonical_trough_lambda context ty in + let context' = (Some (name,Cic.Def (bo,ty)))::context in + Cic.LetIn(name,bo,ty,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 @@ -302,29 +360,32 @@ let canonical t context menv = mk_trans uri_trans ty r m l (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])) -> + | Cic.Appl (([Cic.Const(uri_feq,ens);ty1;ty2;f;x;y;p])) + when LibraryObjects.is_eq_f_URI uri_feq -> let eq = LibraryObjects.eq_URI_of_eq_f_URI uri_feq in let eq_f_sym = Cic.Const (LibraryObjects.eq_f_sym_URI ~eq, []) in - Cic.Appl (([eq_f_sym;ty1;ty2;f;x;y;p])) + let rc = Cic.Appl [eq_f_sym;ty1;ty2;f;x;y;p] in + Utils.debug_print (lazy ("CANONICAL " ^ CicPp.ppterm rc)); + rc | Cic.Appl [Cic.MutConstruct (uri, 0, 1,_);_;_] as t when LibraryObjects.is_eq_URI uri -> t | _ -> Cic.Appl (List.map (canonical context) args)) | Cic.Appl l -> Cic.Appl (List.map (canonical context) l) | _ -> t in - remove_refl (canonical context t) + remove_cycles (remove_refl (canonical context t)) ;; let compose_contexts ctx1 ctx2 = ProofEngineReduction.replace_lifting - ~equality:(=) ~what:[Cic.Implicit(Some `Hole)] ~with_what:[ctx2] ~where:ctx1 + ~equality:(fun _ ->(=)) ~context:[] ~what:[Cic.Implicit(Some `Hole)] ~with_what:[ctx2] ~where:ctx1 ;; let put_in_ctx ctx t = ProofEngineReduction.replace_lifting - ~equality:(=) ~what:[Cic.Implicit (Some `Hole)] ~with_what:[t] ~where:ctx + ~equality:(fun _ -> (=)) ~context:[] ~what:[Cic.Implicit (Some `Hole)] ~with_what:[t] ~where:ctx ;; let mk_eq uri ty l r = @@ -378,8 +439,10 @@ let contextualize uri ty left right t = 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) -> - Cic.LetIn (name,look_ahead (aux uri) body, aux uri ty left right ctx_d ctx_ty rest) + | Cic.LetIn (name,body,bodyty,rest) -> + Cic.LetIn + (name,look_ahead (aux uri) body, bodyty, + 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 -> @@ -497,8 +560,8 @@ let build_proof_step eq lift subst p1 p2 pos l r pred = p ;; -let parametrize_proof menv p l r ty = - let uniq l = HExtlib.list_uniq (List.sort Pervasives.compare l) in +let parametrize_proof p l r = + let uniq l = HExtlib.list_uniq (List.sort (fun (i,_) (j,_) -> Pervasives.compare i j) 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? *) @@ -507,6 +570,21 @@ let parametrize_proof menv p l r ty = HExtlib.list_uniq (List.sort Pervasives.compare parameters) in *) + (* resorts l such that *hopefully* dependencies can be inferred *) + let guess_dependency p l = + match p with + | Cic.Appl ((Cic.Const(uri_ind,ens))::tl) + when LibraryObjects.is_eq_ind_URI uri_ind || + LibraryObjects.is_eq_ind_r_URI uri_ind -> + let ty,_,_,_,_,_ = open_eq_ind tl in + let metas = CicUtil.metas_of_term ty in + let nondep, dep = + List.partition (fun (i,_) -> List.exists (fun (j,_) -> j=i) metas) l + in + nondep@dep + | _ -> l + in + let parameters = guess_dependency p parameters in 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) @@ -514,26 +592,12 @@ let parametrize_proof menv p l r ty = let p = CicSubstitution.lift (lift_no-1) p in let p = ProofEngineReduction.replace_lifting - ~equality:(fun t1 t2 -> + ~equality:(fun _ t1 t2 -> match t1,t2 with Cic.Meta (i,_),Cic.Meta(j,_) -> i=j | _ -> false) + ~context:[] ~what ~with_what ~where:p in - let ty_of_m _ = Cic.Implicit (Some `Type) -(* - let ty_of_m = function - | Cic.Meta (i,_) -> - (try - let _,_,ty = CicUtil.lookup_meta i menv in ty - with CicUtil.Meta_not_found _ -> - prerr_endline "eccoci";assert false) - | _ -> assert false -*) - (* - let ty_of_m _ = ty (*function - | Cic.Meta (i,_) -> List.assoc i menv - | _ -> assert false *) - *) - in + let ty_of_m _ = Cic.Implicit (Some `Type) in let args, proof,_ = List.fold_left (fun (instance,p,n) m -> @@ -571,19 +635,19 @@ let wfo bag goalproof proof id = let string_of_id (id_to_eq,_) names id = if id = 0 then "" else try - let (_,p,(_,l,r,_),m,_) = open_equality (Hashtbl.find id_to_eq id) in + let (_,p,(t,l,r,_),m,_) = open_equality (M.find id id_to_eq) in match p with | Exact t -> 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 [%s]" id +(* "..." *) + (String.concat ", " (List.map (fun (i,_,_) -> string_of_int i) m)) + | Step (_,(step,id1, (dir,id2), p) ) -> + Printf.sprintf "%6d: %s %6d %6d %s =(%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)) *) - "..." + id1 id2 (CicPp.pp l names) (CicPp.pp t names) (CicPp.pp r names) + (String.concat ", " (List.map (fun (i,_,_) -> string_of_int i) m)) + (*"..."*) with Not_found -> assert false @@ -605,14 +669,6 @@ let pp_proof bag names goalproof proof subst id initial_goal = "\nand then subsumed by " ^ string_of_int id ^ " when " ^ Subst.ppsubst subst ;; -module OT = - struct - type t = int - let compare = Pervasives.compare - end - -module M = Map.Make(OT) - let rec find_deps bag m i = if M.mem i m then m else @@ -730,11 +786,11 @@ let build_proof_term bag eq h lift proof = aux proof ;; -let build_goal_proof bag eq l initial ty se context menv = +let build_goal_proof ?(contextualize=true) ?(forward=false) bag 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 bag l initial in let letsno = List.length lets in - let _,mty,_,_ = open_eq ty in + let l = if forward then List.rev l else l in let lift_list l = List.map (fun (i,t) -> i,CicSubstitution.lift 1 t) l in let lets,_,h = List.fold_left @@ -742,19 +798,23 @@ let build_goal_proof bag eq l initial ty se context menv = let p,l,r = proof_of_id bag id in let cic = build_proof_term bag eq h n p in let real_cic,instance = - parametrize_proof menv cic l r (CicSubstitution.lift n mty) + parametrize_proof cic l r in let h = (id, instance)::lift_list h in acc@[id,real_cic],n+1,h) ([],0,[]) lets in + let lets = + List.map (fun (id,cic) -> id,cic,Cic.Implicit (Some `Type)) 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 bag id in let p = build_proof_term bag eq h letsno p in - let pos = if pos = Utils.Left then Utils.Right else Utils.Left in + let pos = if forward then pos else + 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) @@ -778,17 +838,20 @@ let build_goal_proof bag eq l initial ty se context menv = let n,proof = let initial = proof in List.fold_right - (fun (id,cic) (n,p) -> + (fun (id,cic,ty) (n,p) -> n-1, Cic.LetIn ( Cic.Name ("H"^string_of_int id), - cic, p)) + cic, + ty, + p)) lets (letsno-1,initial) in - canonical - (contextualize_rewrites proof (CicSubstitution.lift letsno ty)) - context menv, - se + let proof = + if contextualize + then contextualize_rewrites proof (CicSubstitution.lift letsno ty) + else proof in + canonical proof context menv, se ;; let refl_proof eq_uri ty term = @@ -825,17 +888,17 @@ let relocate newmeta menv to_be_relocated = 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) + (* newsubst, (maxmeta,context,ty)::metasenv, maxmeta+1) *) + newsubst, (maxmeta,[],ty)::metasenv, maxmeta+1) to_be_relocated (Subst.empty_subst, [], newmeta+1) in - let menv = Subst.apply_subst_metasenv subst menv @ newmetasenv in + (* let subst = Subst.flatten_subst subst in *) + let menv = Subst.apply_subst_metasenv subst (menv @ newmetasenv) in subst, menv, newmeta -let fix_metas_goal newmeta goal = +let fix_metas_goal (id_to_eq,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 to_be_relocated = List.map (fun i ,_,_ -> i) menv in let subst, menv, newmeta = relocate newmeta menv to_be_relocated in let ty = Subst.apply_subst subst ty in let proof = @@ -843,17 +906,12 @@ let fix_metas_goal newmeta goal = | [] -> 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) + (id_to_eq,newmeta+1),(proof, menv, ty) ;; -let fix_metas bag newmeta eq = +let fix_metas (id_to_eq, 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)) - in + let to_be_relocated = List.map (fun i ,_,_ -> i) menv 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 @@ -864,8 +922,10 @@ let fix_metas bag newmeta eq = Step (Subst.concat s subst,(r,id1,(pos,id2), pred)) in let p = fix_proof p in - let eq' = mk_equality bag (w, p, (ty, left, right, o), metasenv) in - newmeta+1, eq' + let bag = id_to_eq, newmeta in + let bag, e = mk_equality bag (w, p, (ty, left, right, o), metasenv) in + bag, e +;; exception NotMetaConvertible;; @@ -891,9 +951,12 @@ let meta_convertibility_aux table t1 t2 = aux_ens table ens1 ens2 | C.Cast (s1, t1), C.Cast (s2, t2) | C.Prod (_, s1, t1), C.Prod (_, s2, t2) - | C.Lambda (_, s1, t1), C.Lambda (_, s2, t2) - | C.LetIn (_, s1, t1), C.LetIn (_, s2, t2) -> + | C.Lambda (_, s1, t1), C.Lambda (_, s2, t2) -> + let table = aux table s1 s2 in + aux table t1 t2 + | C.LetIn (_, s1, ty1, t1), C.LetIn (_, s2, ty2, t2) -> let table = aux table s1 s2 in + let table = aux table ty1 ty2 in aux table t1 t2 | C.Appl l1, C.Appl l2 -> ( try List.fold_left2 (fun res t1 t2 -> (aux res t1 t2)) table l1 l2 @@ -973,7 +1036,6 @@ let meta_convertibility_eq eq1 eq2 = false ;; - let meta_convertibility t1 t2 = if t1 = t2 then true @@ -985,6 +1047,32 @@ let meta_convertibility t1 t2 = false ;; +let meta_convertibility_subst t1 t2 menv = + if t1 = t2 then + Some([]) + else + try + let (l,_) = meta_convertibility_aux ([],[]) t1 t2 in + let subst = + List.map + (fun (x,y) -> + try + let (_,c,t) = CicUtil.lookup_meta x menv in + let irl = + CicMkImplicit.identity_relocation_list_for_metavariable c in + (y,(c,Cic.Meta(x,irl),t)) + with CicUtil.Meta_not_found _ -> + try + let (_,c,t) = CicUtil.lookup_meta y menv in + let irl = + CicMkImplicit.identity_relocation_list_for_metavariable c in + (x,(c,Cic.Meta(y,irl),t)) + with CicUtil.Meta_not_found _ -> assert false) l in + Some subst + with NotMetaConvertible -> + None +;; + exception TermIsNotAnEquality;; let term_is_equality term = @@ -994,15 +1082,15 @@ let term_is_equality term = | _ -> false ;; -let equality_of_term bag proof term = +let equality_of_term bag proof term newmetas = match term with | 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 - let e = mk_equality bag (w, Exact proof, stat,[]) in - e + let bag, e = mk_equality bag (w, Exact proof, stat,newmetas) in + bag, e | _ -> raise TermIsNotAnEquality ;; @@ -1056,12 +1144,12 @@ let symmetric bag eq_ty l id uri m = Exact (Cic.Appl [Cic.MutConstruct(uri,0,1,[]);eq_ty;l]) in - let id1 = - let eq = mk_equality bag (0,prefl,(eq_ty,l,l,Utils.Eq),m) in + let bag, id1 = + let bag, eq = mk_equality bag (0,prefl,(eq_ty,l,l,Utils.Eq),m) in let (_,_,_,_,id) = open_equality eq in - id + bag, id in - Step(Subst.empty_subst, + bag, Step(Subst.empty_subst, (Demodulation,id1,(Utils.Left,id),pred)) ;; @@ -1074,8 +1162,7 @@ module IntSet = Set.Make(IntOT);; let n_purged = ref 0;; -let collect ((id_to_eq,_) as bag) alive1 alive2 alive3 = -(* let _ = <:start> in *) +let collect ((id_to_eq,maxmeta) as bag) alive1 alive2 alive3 = let deps_of id = let p,_,_ = proof_of_id bag id in match p with @@ -1091,18 +1178,13 @@ let collect ((id_to_eq,_) as bag) alive1 alive2 alive3 = 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 + M.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 + List.fold_right M.remove to_purge id_to_eq, maxmeta ;; let get_stats () = "" @@ -1123,7 +1205,7 @@ let rec pp_proofterm name t context = | _ -> assert false in let rec skip_letin ctx = function - | Cic.LetIn (n,b,t) -> + | Cic.LetIn (n,b,_,t) -> pp_proofterm (Some (rename "Lemma " n)) b ctx:: skip_letin ((Some n)::ctx) t | t -> @@ -1145,7 +1227,7 @@ let rec pp_proofterm name t context = when Pcre.pmatch ~pat:"eq_f" (UriManager.string_of_uri uri)-> pp true p | Cic.Appl [Cic.Const (uri,[]);_;_;_;_;_;p] - when Pcre.pmatch ~pat:"eq_f1" (UriManager.string_of_uri uri)-> + when Pcre.pmatch ~pat:"eq_OF_eq" (UriManager.string_of_uri uri)-> pp true p | Cic.Appl [Cic.MutConstruct (uri,_,_,[]);_;_;t;p] when Pcre.pmatch ~pat:"ex.ind" (UriManager.string_of_uri uri)-> @@ -1182,3 +1264,117 @@ let pp_proofterm t = pp_proofterm (Some (Cic.Name "Hypothesis")) t [] ;; +let initial_nameset_list = [ + "x"; "y"; "z"; "t"; "u"; "v"; "a"; "b"; "c"; "d"; + "e"; "l"; "m"; "n"; "o"; "p"; "q"; "r"; +] + +module S = Set.Make(String) + +let initial_nameset = List.fold_right S.add initial_nameset_list S.empty, [];; + +let freshname (nameset, subst) term = + let m = CicUtil.metas_of_term term in + let nameset, subst = + List.fold_left + (fun (set,rc) (m,_) -> + if List.mem_assoc m rc then set,rc else + let name = S.choose set in + let set = S.remove name set in + set, + (m,Cic.Const(UriManager.uri_of_string + ("cic:/"^name^".con"),[]))::rc) + (nameset,subst) m + in + let term = + ProofEngineReduction.replace + ~equality:(fun i t -> match t with Cic.Meta (j,_) -> i=j| _ -> false) + ~what:(List.map fst subst) + ~with_what:(List.map snd subst) ~where:term + in + (nameset, subst), term +;; + +let remove_names_in_context (set,subst) names = + List.fold_left + (fun s n -> + match n with Some (Cic.Name n) -> S.remove n s | _ -> s) + set names, subst +;; + +let string_of_id2 (id_to_eq,_) names nameset id = + if id = 0 then "" else + try + let (_,_,(_,l,r,_),_,_) = open_equality (M.find id id_to_eq) in + let nameset, l = freshname nameset l in + let nameset, r = freshname nameset r in + Printf.sprintf "%s = %s" (CicPp.pp l names) (CicPp.pp r names) + with + Not_found -> assert false +;; + +let draw_proof bag names goal_proof proof id = + let b = Buffer.create 100 in + let fmt = Format.formatter_of_buffer b in + let sint = string_of_int in + let fst3 (x,_,_) = x in + let visited = ref [] in + let nameset = remove_names_in_context initial_nameset names in + let rec fact id = function + | Exact t -> + if not (List.mem id !visited) then + begin + visited := id :: !visited; + let nameset, t = freshname nameset t in + let t = CicPp.pp t names in + GraphvizPp.Dot.node (sint id) + ~attrs:["label",t^":"^string_of_id2 bag names nameset id; + "shape","rectangle"] fmt; + end + | Step (_,(_,id1,(_,id2),_)) -> + GraphvizPp.Dot.edge (sint id) (sint id1) fmt; + GraphvizPp.Dot.edge (sint id) (sint id2) fmt; + let p1,_,_ = proof_of_id bag id1 in + let p2,_,_ = proof_of_id bag id2 in + fact id1 p1; + fact id2 p2; + if not (List.mem id !visited); then + begin + visited := id :: !visited; + GraphvizPp.Dot.node (sint id) + ~attrs:["label",sint id^":"^string_of_id2 bag names nameset id; + "shape","ellipse"] fmt + end + in + let sleft acc (_,_,id,_,_) = + if acc != 0 then GraphvizPp.Dot.edge (sint acc) (sint id) fmt; + fact id (fst3 (proof_of_id bag id)); + id + in + GraphvizPp.Dot.header ~node_attrs:["fontsize","10"; ] fmt; + ignore(List.fold_left sleft id goal_proof); + GraphvizPp.Dot.trailer fmt; + let oc = open_out "/tmp/matita_paramod.dot" in + Buffer.output_buffer oc b; + close_out oc; + Utils.debug_print (lazy "dot!"); + ignore(Unix.system + "dot -Tps -o /tmp/matita_paramod.eps /tmp/matita_paramod.dot" +(* "cat /tmp/matita_paramod.dot| tred | dot -Tps -o /tmp/matita_paramod.eps" *) + ); + ignore(Unix.system "gv /tmp/matita_paramod.eps"); +;; + +let saturate_term (id_to_eq, maxmeta) metasenv subst context term = + let maxmeta = max maxmeta (CicMkImplicit.new_meta metasenv subst) in + let head, metasenv, args, newmeta = + TermUtil.saturate_term maxmeta metasenv context term 0 + in + (id_to_eq, newmeta), head, metasenv, args +;; + +let push_maxmeta (id_to_eq, maxmeta) m = id_to_eq, max maxmeta m ;; +let filter_metasenv_gt_maxmeta (_,maxmeta) = + List.filter (fun (j,_,_) -> j >= maxmeta) +;; +let maxmeta = snd;;