X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=components%2Ftactics%2Fparamodulation%2Fequality.ml;h=7893ecba6142ef4a5934d3edc0fd18db3ec51a14;hb=42f2dc48b4fef5b404f406bf512d6a0cde35c067;hp=4414d2f435f3af14a1d8cc1d32c131bd0b241db7;hpb=b1c222ae8d9bee83d6c5723533a1395d7353893a;p=helm.git diff --git a/components/tactics/paramodulation/equality.ml b/components/tactics/paramodulation/equality.ml index 4414d2f43..7893ecba6 100644 --- a/components/tactics/paramodulation/equality.ml +++ b/components/tactics/paramodulation/equality.ml @@ -23,12 +23,13 @@ * http://cs.unibo.it/helm/. *) -let _profiler = <:profiler<_profiler>>;; +(* let _profiler = <:profiler<_profiler>>;; *) (* $Id: inference.ml 6245 2006-04-05 12:07:51Z tassi $ *) type rule = SuperpositionRight | SuperpositionLeft | Demodulation type uncomparable = int -> int + type equality = uncomparable * (* trick to break structural equality *) int * (* weight *) @@ -45,28 +46,30 @@ and proof = (* subst, (rule,eq1, eq2,predicate) *) 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 type goal = goal_proof * Cic.metasenv * Cic.term (* globals *) -let maxid = ref 0;; -let id_to_eq = Hashtbl.create 1024;; +let mk_equality_bag () = + Hashtbl.create 1024, ref 0 +;; -let freshid () = - incr maxid; !maxid +let freshid (_,i) = + incr i; !i ;; -let reset () = - maxid := 0; - Hashtbl.clear id_to_eq +let add_to_bag (id_to_eq,_) id eq = + Hashtbl.add id_to_eq id eq ;; let uncomparable = fun _ -> 0 -let mk_equality (weight,p,(ty,l,r,o),m) = - let id = freshid () in +let mk_equality bag (weight,p,(ty,l,r,o),m) = + let id = freshid bag in let eq = (uncomparable,weight,p,(ty,l,r,o),m,id) in - Hashtbl.add id_to_eq id eq; + add_to_bag bag id eq; eq ;; @@ -93,7 +96,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 @@ -101,14 +105,40 @@ 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,_,_) = Pervasives.compare s1 s2 ;; -let proof_of_id id = +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 (w1,p1,(_,_,_,_),_,_) = open_equality eq1 in + let (w2,p2,(_,_,_,_),_,_) = open_equality eq2 in + let current = max current w1 in + let current = max_weight_in_proof bag current p1 in + let current = max current w2 in + max_weight_in_proof bag current p2 + +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 (w,p,(_,_,_,_),_,_) = open_equality eq in + let current = max current w in + max_weight_in_proof bag current p) + +let max_weight bag goal_proof proof = + let current = max_weight_in_proof bag 0 proof in + max_weight_in_goal_proof bag current goal_proof + +let proof_of_id (id_to_eq,_) id = try let (_,p,(_,l,r,_),_,_) = open_equality (Hashtbl.find id_to_eq id) in p,l,r @@ -116,7 +146,7 @@ let proof_of_id id = Not_found -> assert false -let string_of_proof ?(names=[]) p gp = +let string_of_proof ?(names=[]) bag p gp = let str_of_pos = function | Utils.Left -> "left" | Utils.Right -> "right" @@ -131,8 +161,8 @@ let string_of_proof ?(names=[]) p gp = Printf.sprintf "%s%s(%s|%d with %d dir %s pred %s))\n" 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)) + aux (margin+1) (Printf.sprintf "%d" eq1) (fst3 (proof_of_id bag eq1)) ^ + aux (margin+1) (Printf.sprintf "%d" eq2) (fst3 (proof_of_id bag eq2)) in aux 0 "" p ^ String.concat "\n" @@ -141,11 +171,11 @@ let string_of_proof ?(names=[]) p gp = (Printf.sprintf "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))) + aux 1 (Printf.sprintf "%d " i) (fst3 (proof_of_id bag i))) gp) ;; -let rec depend eq id seen = +let rec depend ((id_to_eq,_) as bag) eq id seen = let (_,p,(_,_,_,_),_,ideq) = open_equality eq in if List.mem ideq seen then false,seen @@ -159,11 +189,11 @@ let rec depend eq id seen = 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 b1,seen = depend bag eq1 id seen in + if b1 then b1,seen else depend bag eq2 id seen ;; -let depend eq id = fst (depend eq id []);; +let depend bag eq id = fst (depend bag eq id []);; let ppsubst = Subst.ppsubst ~names:[];; @@ -172,7 +202,7 @@ let build_ens uri termlist = let obj, _ = CicEnvironment.get_obj CicUniv.empty_ugraph uri in match obj with | Cic.Constant (_, _, _, uris, _) -> - assert (List.length uris <= List.length termlist); + (* assert (List.length uris <= List.length termlist); *) let rec aux = function | [], tl -> [], tl | (uri::uris), (term::tl) -> @@ -195,7 +225,8 @@ let mk_trans uri ty t1 t2 t3 p12 p23 = ;; let mk_eq_ind uri ty what pred p1 other p2 = - Cic.Appl [Cic.Const (uri, []); ty; what; pred; p1; other; p2] + let ens, args = build_ens uri [ty; what; pred; p1; other; p2] in + Cic.Appl (Cic.Const (uri, ens) :: args) ;; let p_of_sym ens tl = @@ -229,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 = @@ -237,35 +268,49 @@ 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 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) @@ -282,11 +327,18 @@ let canonical t context menv = Cic.LetIn (name,remove_refl bo,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 bo = canonical_trough_lambda context bo in let context' = (Some (name,Cic.Def (bo,None)))::context in - Cic.LetIn(name,canonical context bo,canonical context' rest) + Cic.LetIn(name,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 @@ -299,91 +351,42 @@ 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])) -> - - 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) + | 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 - 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 -> - let ty, what, pred, p1, other, p2 = - match tl with - | [ty;what;pred;p1;other;p2] -> ty, what, pred, p1, other, p2 - | _ -> assert false - in - let pred,l,r = - match pred with - | Cic.Lambda (name,s,Cic.Appl [Cic.MutInd(uri,0,ens);ty;l;r]) - when LibraryObjects.is_eq_URI uri -> - Cic.Lambda - (name,s,Cic.Appl [Cic.MutInd(uri,0,ens);ty;r;l]),l,r - | _ -> - prerr_endline (CicPp.ppterm pred); - assert false - in - let l = CicSubstitution.subst what l in - let r = CicSubstitution.subst what r in - Cic.Appl - [he;ty;what;pred; - canonical (mk_sym uri_sym ty l r p1);other;canonical p2] -*) + 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 ty_of_lambda = function - | Cic.Lambda (_,ty,_) -> ty - | _ -> assert false -;; - 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 = - Cic.Appl [Cic.MutInd(uri,0,[]);ty;l;r] + let ens, args = build_ens uri [ty; l; r] in + Cic.Appl (Cic.MutInd(uri,0,ens) :: args) ;; let mk_refl uri ty t = - Cic.Appl [Cic.MutConstruct(uri,0,1,[]);ty;t] + let ens, args = build_ens uri [ty; t] in + Cic.Appl (Cic.MutConstruct(uri,0,1,ens) :: args) ;; let open_eq = function @@ -393,28 +396,42 @@ let open_eq = function ;; let mk_feq uri_feq ty ty1 left pred right t = - Cic.Appl [Cic.Const(uri_feq,[]);ty;ty1;pred;left;right;t] + let ens, args = build_ens uri_feq [ty;ty1;pred;left;right;t] in + Cic.Appl (Cic.Const(uri_feq,ens) :: args) +;; + +let rec look_ahead aux = function + | Cic.Appl ((Cic.Const(uri_ind,ens))::tl) as t + when LibraryObjects.is_eq_ind_URI uri_ind || + LibraryObjects.is_eq_ind_r_URI uri_ind -> + let ty1,what,pred,p1,other,p2 = open_eq_ind tl in + let ty2,eq,lp,rp = open_pred pred in + let hole = Cic.Implicit (Some `Hole) in + let ty2 = CicSubstitution.subst hole ty2 in + aux ty1 (CicSubstitution.subst other lp) (CicSubstitution.subst other rp) hole ty2 t + | Cic.Lambda (n,s,t) -> Cic.Lambda (n,s,look_ahead aux t) + | t -> t ;; let contextualize uri ty left right t = let hole = Cic.Implicit (Some `Hole) in - (* aux [uri] [ty] [left] [right] [ctx] [t] + (* aux [uri] [ty] [left] [right] [ctx] [ctx_ty] [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 hole. Cic.Implicit(Some `Hole) is the empty context - * ty_ctx is the type of ctx_d + * ctx_ty is the type of ctx *) - let rec aux uri ty left right ctx_d ctx_ty = function + let rec aux uri ty left right ctx_d ctx_ty t = + match t with | 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.LetIn (name,look_ahead (aux uri) 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 -> @@ -443,8 +460,8 @@ let contextualize uri ty left right t = let c_what = put_in_ctx ctx_c what in (* now put the proofs in the compound context *) let p1 = (* p1: dc_what = d_m *) - if is_not_fixed_lp then - aux uri ty2 c_what m ctx_d ctx_ty p1 + if is_not_fixed_lp then + aux uri ty2 c_what m ctx_d ctx_ty p1 else mk_sym uri_sym ctx_ty d_m dc_what (aux uri ty2 m c_what ctx_d ctx_ty p1) @@ -453,7 +470,7 @@ let contextualize uri ty left right t = if avoid_eq_ind then mk_sym uri_sym ctx_ty dc_what dc_other (aux uri ty1 what other ctx_dc ctx_ty p2) - else + else 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 @@ -471,9 +488,8 @@ let contextualize uri ty left right t = | t -> (* 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 uri_feq = LibraryObjects.eq_f_URI ~eq:uri in let pred = (* let r = CicSubstitution.lift 1 (put_in_ctx ctx_d left) in *) let l = @@ -533,14 +549,31 @@ let build_proof_step eq lift subst p1 p2 pos l r pred = p ;; -let parametrize_proof 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? *) +(* let parameters = 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) @@ -548,20 +581,18 @@ let parametrize_proof 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 _ = 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 -> (instance@[m], Cic.Lambda - (Cic.Name ("x"^string_of_int n), + (Cic.Name ("X"^string_of_int n), CicSubstitution.lift (lift_no - n - 1) (ty_of_m m), p), n+1)) @@ -572,9 +603,9 @@ let parametrize_proof p l r ty = proof, instance ;; -let wfo goalproof proof id = +let wfo bag goalproof proof id = let rec aux acc id = - let p,_,_ = proof_of_id id in + let p,_,_ = proof_of_id bag id in match p with | Exact _ -> if (List.mem id acc) then acc else id :: acc | Step (_,(_,id1, (_,id2), _)) -> @@ -590,25 +621,27 @@ let wfo goalproof proof id = List.fold_left (fun acc (_,_,id,_,_) -> aux acc id) acc goalproof ;; -let string_of_id names 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 (Hashtbl.find id_to_eq id) 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 -let pp_proof names goalproof proof subst id initial_goal = - String.concat "\n" (List.map (string_of_id names) (wfo goalproof proof id)) ^ +let pp_proof bag names goalproof proof subst id initial_goal = + String.concat "\n" (List.map (string_of_id bag names) (wfo bag goalproof proof id)) ^ "\ngoal:\n " ^ (String.concat "\n " (fst (List.fold_right @@ -633,24 +666,24 @@ module OT = module M = Map.Make(OT) -let rec find_deps m i = +let rec find_deps bag m i = if M.mem i m then m else - let p,_,_ = proof_of_id i in + let p,_,_ = proof_of_id bag 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 + let m = find_deps bag m id1 in + let m = find_deps bag 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 = +let topological_sort bag l = (* build the partial order relation *) - let m = List.fold_left (fun m i -> find_deps m i) M.empty l in + let m = List.fold_left (fun m i -> find_deps bag m i) M.empty l in let m = (* keep only deps inside l *) List.fold_left (fun m' i -> @@ -682,14 +715,14 @@ let topological_sort l = (* returns the list of ids that should be factorized *) -let get_duplicate_step_in_wfo l p = +let get_duplicate_step_in_wfo bag 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 + let p,_,_ = proof_of_id bag i in match p with | Exact _ -> true | _ -> @@ -704,23 +737,23 @@ let get_duplicate_step_in_wfo l p = | 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) + if go_on_1 then aux (let p,_,_ = proof_of_id bag i1 in p); + if go_on_2 then aux (let p,_,_ = proof_of_id bag i2 in p) in aux p; List.iter - (fun (_,_,id,_,_) -> aux (let p,_,_ = proof_of_id id in p)) + (fun (_,_,id,_,_) -> aux (let p,_,_ = proof_of_id bag 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 + let res = topological_sort bag (List.map (fun (i,_) -> i) proofs) in res ;; -let build_proof_term eq h lift proof = +let build_proof_term bag eq h lift proof = let proof_of_id aux id = - let p,l,r = proof_of_id id in + let p,l,r = proof_of_id bag id in try List.assoc id h,l,r with Not_found -> aux p, l, r in let rec aux = function @@ -750,19 +783,18 @@ let build_proof_term eq h lift proof = aux proof ;; -let build_goal_proof eq l initial ty se context menv = +let build_goal_proof 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 l initial 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 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 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 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) @@ -772,8 +804,8 @@ let build_goal_proof eq l initial ty se context menv = 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 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 varname = match rule with @@ -791,9 +823,9 @@ let build_goal_proof eq l initial ty se context menv = 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 + List.map (fun x -> Subst.apply_subst(*_lift letsno*) subst x) se in - aux se (build_proof_term eq h letsno initial) l + aux se (build_proof_term bag eq h letsno initial) l in let n,proof = let initial = proof in @@ -815,7 +847,7 @@ let refl_proof eq_uri ty term = Cic.Appl [Cic.MutConstruct (eq_uri, 0, 1, []); ty; term] ;; -let metas_of_proof p = +let metas_of_proof bag p = let eq = match LibraryObjects.eq_URI () with | Some u -> u @@ -824,7 +856,7 @@ let metas_of_proof p = (ProofEngineTypes.Fail (lazy "No default equality defined when calling metas_of_proof")) in - let p = build_proof_term eq [] 0 p in + let p = build_proof_term bag eq [] 0 p in Utils.metas_of_term p ;; @@ -866,13 +898,14 @@ let fix_metas_goal newmeta goal = newmeta+1,(proof, menv, ty) ;; -let fix_metas newmeta eq = +let fix_metas bag 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)) + (Utils.metas_of_term left @ Utils.metas_of_term right @ + Utils.metas_of_term ty)) in let subst, metasenv, newmeta = relocate newmeta menv to_be_relocated in let ty = Subst.apply_subst subst ty in @@ -884,17 +917,18 @@ let fix_metas newmeta eq = 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 + let eq' = mk_equality bag (w, p, (ty, left, right, o), metasenv) in newmeta+1, eq' exception NotMetaConvertible;; let meta_convertibility_aux table t1 t2 = let module C = Cic in - let rec aux ((table_l, table_r) as 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) when m1 = m2 -> table + | C.Meta (m1, tl1), C.Meta (m2, tl2) when m1 < m2 -> aux table t2 t1 | 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 @@ -904,18 +938,7 @@ let meta_convertibility_aux table t1 t2 = in if (m1_binding <> m2) || (m2_binding <> m1) then raise NotMetaConvertible - else ( - try - List.fold_left2 - (fun res t1 t2 -> - match t1, t2 with - | None, Some _ | Some _, None -> raise NotMetaConvertible - | None, None -> res - | Some t1, Some t2 -> (aux res t1 t2)) - (table_l, table_r) tl1 tl2 - with Invalid_argument _ -> - raise NotMetaConvertible - ) + else table_l,table_r | C.Var (u1, ens1), C.Var (u2, ens2) | C.Const (u1, ens1), C.Const (u2, ens2) when (UriManager.eq u1 u2) -> aux_ens table ens1 ens2 @@ -991,30 +1014,55 @@ let meta_convertibility_eq eq1 eq2 = true else try - let table = meta_convertibility_aux ([], []) left left' in + let table = meta_convertibility_aux ([],[]) left left' in let _ = meta_convertibility_aux table right right' in true with NotMetaConvertible -> try - let table = meta_convertibility_aux ([], []) left right' in + let table = meta_convertibility_aux ([],[]) left right' in let _ = meta_convertibility_aux table right left' in true with NotMetaConvertible -> false ;; - let meta_convertibility t1 t2 = if t1 = t2 then true else try - ignore(meta_convertibility_aux ([], []) t1 t2); + ignore(meta_convertibility_aux ([],[]) t1 t2); true with NotMetaConvertible -> 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 = @@ -1024,14 +1072,14 @@ let term_is_equality term = | _ -> false ;; -let equality_of_term proof term = +let equality_of_term bag proof term = 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 (w, Exact proof, stat,[]) in + let e = mk_equality bag (w, Exact proof, stat,[]) in e | _ -> raise TermIsNotAnEquality @@ -1039,14 +1087,16 @@ let equality_of_term proof term = let is_weak_identity eq = let _,_,(_,left, right,_),_,_ = open_equality eq in - left = right || meta_convertibility left right + left = right + (* doing metaconv here is meaningless *) ;; let is_identity (_, context, ugraph) eq = let _,_,(ty,left,right,_),menv,_ = open_equality eq in - left = right || - (* (meta_convertibility left right)) *) - fst (CicReduction.are_convertible ~metasenv:menv context left right ugraph) + (* doing metaconv here is meaningless *) + left = right +(* fst (CicReduction.are_convertible ~metasenv:menv context left right ugraph) + * *) ;; @@ -1072,7 +1122,7 @@ let term_of_equality eq_uri equality = menv (argsno, t)) ;; -let symmetric eq_ty l id uri m = +let symmetric bag eq_ty l id uri m = let eq = Cic.MutInd(uri,0,[]) in let pred = Cic.Lambda (Cic.Name "Sym",eq_ty, @@ -1085,7 +1135,7 @@ let symmetric eq_ty l id uri m = [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 eq = mk_equality bag (0,prefl,(eq_ty,l,l,Utils.Eq),m) in let (_,_,_,_,id) = open_equality eq in id in @@ -1102,10 +1152,10 @@ module IntSet = Set.Make(IntOT);; let n_purged = ref 0;; -let collect alive1 alive2 alive3 = - let _ = <:start> in +let collect ((id_to_eq,_) as bag) alive1 alive2 alive3 = +(* let _ = <:start> in *) let deps_of id = - let p,_,_ = proof_of_id id in + let p,_,_ = proof_of_id bag id in match p with | Exact _ -> IntSet.empty | Step (_,(_,id1,(_,id2),_)) -> @@ -1126,14 +1176,188 @@ let collect alive1 alive2 alive3 = in n_purged := !n_purged + List.length to_purge; List.iter (Hashtbl.remove id_to_eq) to_purge; - let _ = <:stop> in () +(* let _ = <:stop> in () *) ;; let id_of e = let _,_,_,_,id = open_equality e in id ;; -let get_stats () = +let get_stats () = "" +(* <:show> ^ "# of purged eq by the collector: " ^ string_of_int !n_purged ^ "\n" +*) +;; + +let rec pp_proofterm name t context = + let rec skip_lambda tys ctx = function + | Cic.Lambda (n,s,t) -> skip_lambda (s::tys) ((Some n)::ctx) t + | t -> ctx,tys,t + in + let rename s name = + match name with + | Cic.Name s1 -> Cic.Name (s ^ s1) + | _ -> assert false + in + let rec skip_letin ctx = function + | Cic.LetIn (n,b,t) -> + pp_proofterm (Some (rename "Lemma " n)) b ctx:: + skip_letin ((Some n)::ctx) t + | t -> + let ppterm t = CicPp.pp t ctx in + let rec pp inner = function + | Cic.Appl [Cic.Const (uri,[]);_;l;m;r;p1;p2] + when Pcre.pmatch ~pat:"trans_eq" (UriManager.string_of_uri uri)-> + if not inner then + (" " ^ ppterm l) :: pp true p1 @ + [ " = " ^ ppterm m ] @ pp true p2 @ + [ " = " ^ ppterm r ] + else + pp true p1 @ + [ " = " ^ ppterm m ] @ pp true p2 + | Cic.Appl [Cic.Const (uri,[]);_;l;m;p] + when Pcre.pmatch ~pat:"sym_eq" (UriManager.string_of_uri uri)-> + pp true p + | Cic.Appl [Cic.Const (uri,[]);_;_;_;_;_;p] + 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_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)-> + [ "witness " ^ ppterm t ] @ pp true p + | Cic.Appl (t::_) ->[ " [by " ^ ppterm t ^ "]"] + | t ->[ " [by " ^ ppterm t ^ "]"] + in + let rec compat = function + | a::b::tl -> (b ^ a) :: compat tl + | h::[] -> [h] + | [] -> [] + in + let compat l = List.hd l :: compat (List.tl l) in + compat (pp false t) @ ["";""] + in + let names, tys, body = skip_lambda [] context t in + let ppname name = (match name with Some (Cic.Name s) -> s | _ -> "") in + ppname name ^ ":\n" ^ + (if context = [] then + let rec pp_l ctx = function + | (t,name)::tl -> + " " ^ ppname name ^ ": " ^ CicPp.pp t ctx ^ "\n" ^ + pp_l (name::ctx) tl + | [] -> "\n\n" + in + pp_l [] (List.rev (List.combine tys names)) + else "") + ^ + String.concat "\n" (skip_letin names body) +;; + +let pp_proofterm t = + "\n\n" ^ + 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"); +;; +