X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fsoftware%2Fcomponents%2Ftactics%2Fparamodulation%2Fequality.ml;h=bfbab9c3ec43c878a9f4f08be05dbeab1f26acd0;hb=04f22df647f35080b499b720bca7bc0eb1794c64;hp=1bc87f8c54fd6e235b903a405e6422b7486ba62e;hpb=d924c0133e2ecd9b68f23eb00cb4230320f155df;p=helm.git diff --git a/helm/software/components/tactics/paramodulation/equality.ml b/helm/software/components/tactics/paramodulation/equality.ml index 1bc87f8c5..bfbab9c3e 100644 --- a/helm/software/components/tactics/paramodulation/equality.ml +++ b/helm/software/components/tactics/paramodulation/equality.ml @@ -260,7 +260,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 = @@ -290,7 +290,7 @@ let canonical t context menv = [] -> List.rev acc | (l',p)::tl when l=l' -> if acc <> [] then -prerr_endline ("!!! RISPARMIO " ^ string_of_int (List.length acc) ^ " PASSI"); +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 @@ -323,8 +323,8 @@ prerr_endline ("!!! RISPARMIO " ^ string_of_int (List.length acc) ^ " PASSI"); 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_trough_lambda context = function @@ -335,10 +335,11 @@ prerr_endline ("!!! RISPARMIO " ^ string_of_int (List.length acc) ^ " PASSI"); and canonical context t = match t with - | Cic.LetIn(name,bo,rest) -> + | Cic.LetIn(name,bo,ty,rest) -> let bo = canonical_trough_lambda context bo in - let context' = (Some (name,Cic.Def (bo,None)))::context in - Cic.LetIn(name,bo,canonical context' rest) + 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 @@ -358,7 +359,7 @@ prerr_endline ("!!! RISPARMIO " ^ string_of_int (List.length acc) ^ " PASSI"); Cic.Const (LibraryObjects.eq_f_sym_URI ~eq, []) in let rc = Cic.Appl [eq_f_sym;ty1;ty2;f;x;y;p] in - prerr_endline ("CANONICAL " ^ CicPp.ppterm rc); + 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 @@ -371,12 +372,12 @@ prerr_endline ("!!! RISPARMIO " ^ string_of_int (List.length acc) ^ " PASSI"); 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 = @@ -430,8 +431,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 -> @@ -581,8 +584,9 @@ let parametrize_proof p l r = 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) in @@ -799,6 +803,9 @@ let build_goal_proof bag eq l initial ty se context menv = 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 @@ -829,11 +836,13 @@ 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 @@ -943,9 +952,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 @@ -1025,7 +1037,6 @@ let meta_convertibility_eq eq1 eq2 = false ;; - let meta_convertibility t1 t2 = if t1 = t2 then true @@ -1037,6 +1048,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 = @@ -1175,7 +1212,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 -> @@ -1197,7 +1234,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)-> @@ -1234,3 +1271,104 @@ 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 (Hashtbl.find id_to_eq id) 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"); +;; +