X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fsoftware%2Fcomponents%2Ftactics%2Fparamodulation%2Fequality.ml;h=3bff5b57460bc4decc952b913a83f4c410fb4d29;hb=08a92d276c5477968b02f31097b6ed03185f34eb;hp=b10dc818e80af3921c0385e4fac8ea38cef5cd20;hpb=9809bb28066665067dc4669a631fdd4fe18b6a22;p=helm.git diff --git a/helm/software/components/tactics/paramodulation/equality.ml b/helm/software/components/tactics/paramodulation/equality.ml index b10dc818e..3bff5b574 100644 --- a/helm/software/components/tactics/paramodulation/equality.ml +++ b/helm/software/components/tactics/paramodulation/equality.ml @@ -89,7 +89,7 @@ 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 @@ -97,7 +97,7 @@ 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,_,_) = @@ -141,17 +141,26 @@ let string_of_proof ?(names=[]) p gp = 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 id + 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 *) @@ -199,6 +208,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 @@ -289,12 +305,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 = @@ -312,15 +328,20 @@ let open_eq = function ;; 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 *) let rec aux uri ty left right ctx_d = 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) | Cic.LetIn (name,body,rest) -> (* we should go in body *) Cic.LetIn (name,body,aux uri ty left right ctx_d rest) @@ -338,7 +359,7 @@ let contextualize uri ty left right t = 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 + let ctx_c = CicSubstitution.subst hole ctx_c in m, ctx_c in (* create the compound context and put the terms under it *) @@ -380,9 +401,11 @@ let contextualize uri ty left right t = let uri_ind = LibraryObjects.eq_ind_URI ~eq:uri 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 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 ty in Cic.Lambda (Cic.Name "foo",ty,(mk_eq uri lty l r)) in @@ -392,15 +415,21 @@ let contextualize uri ty left right t = mk_sym uri_sym ty d_right d_left (mk_eq_ind uri_ind ty left pred refl_eq right t) in - let empty_context = Cic.Rel 1 in - aux uri ty left right empty_context t + aux uri ty left right hole t ;; let contextualize_rewrites t ty = let eq,ty,l,r = open_eq ty in contextualize eq ty l r t ;; - + +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 ?(sym=false) 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 @@ -502,19 +531,16 @@ let string_of_id names id = | 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)) + (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_of_rule step) id1 id2 (CicPp.pp l names) (CicPp.pp r names) - (String.concat ", " (List.map (fun (i,_,_) -> string_of_int i) m)) + (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 = - prerr_endline ("AAAAA" ^ string_of_int id); - prerr_endline (String.concat "+" (List.map string_of_int (wfo goalproof proof - id))); String.concat "\n" (List.map (string_of_id names) (wfo goalproof proof id)) ^ "\ngoal:\n " ^ (String.concat "\n " @@ -532,6 +558,54 @@ let pp_proof 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 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 + M.add i (M.find id1 m @ M.find id2 m @ [id1;id2]) 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 = 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 = + let keys = keys m in + let ok = split keys m in + let m = purge ok m in + ok @ (if ok = [] then [] else aux m) + in + aux m +;; + + (* returns the list of ids that should be factorized *) let get_duplicate_step_in_wfo l p = let ol = List.rev l in @@ -539,36 +613,33 @@ let get_duplicate_step_in_wfo l p = (* 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 n = + let add i = let p,_,_ = proof_of_id i in match p with | Exact _ -> true | _ -> - try let (pos,no) = Hashtbl.find h i in Hashtbl.replace h i (pos,no+1);false - with Not_found -> Hashtbl.add h i (n,1);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 n = function - | Exact _ -> n + let rec aux = function + | Exact _ -> () | Step (_,(_,i1,(_,i2),_)) -> - let go_on_1 = add i1 n in - let go_on_2 = add i2 n in - max - (if go_on_1 then aux (n+1) (let p,_,_ = proof_of_id i1 in p) else n+1) - (if go_on_2 then aux (n+1) (let p,_,_ = proof_of_id i2 in p) else n+1) - in - let i = aux 0 p in - let _ = - List.fold_left - (fun acc (_,_,id,_,_) -> aux acc (let p,_,_ = proof_of_id id in p)) - i ol + 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 + 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 (pos,count) acc->(k,pos,count)::acc) h [] in - let proofs = List.filter (fun (_,_,c) -> c > 1) proofs in - let proofs = - List.sort (fun (_,c1,_) (_,c2,_) -> Pervasives.compare c2 c1) proofs - in - List.map (fun (i,_,_) -> i) proofs + 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 build_proof_term h lift proof = @@ -578,15 +649,26 @@ let build_proof_term h lift proof = in let rec aux = function | Exact term -> CicSubstitution.lift lift term - | Step (subst,(_, id1, (pos,id2), pred)) -> + | 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 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 +(* 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 ;; @@ -617,20 +699,19 @@ let build_goal_proof l initial ty se = let p,l,r = proof_of_id id in let p = build_proof_term h letsno p in let pos = if pos = Utils.Left then Utils.Right else Utils.Left in - let sym,pred = - match rule with - | SuperpositionLeft when pos = Utils.Left -> - let pred = - match pred with - | Cic.Lambda (name,ty,Cic.Appl[eq;ty1;l;r]) -> - Cic.Lambda (name,ty,Cic.Appl[eq;ty1;r;l]) - | _ -> assert false - in - true, pred - | _ -> false,pred - 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 ~sym letsno subst current_proof p pos l r pred + build_proof_step 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, @@ -648,13 +729,15 @@ let build_goal_proof l initial ty se = cic, p)) lets (letsno-1,initial) in - (*canonical (contextualize_rewrites proof (CicSubstitution.lift letsno ty))*)proof, se + (proof,se) + (* canonical (contextualize_rewrites proof (CicSubstitution.lift letsno ty)), + se *) ;; let refl_proof ty term = Cic.Appl [Cic.MutConstruct - (LibraryObjects.eq_URI (), 0, 1, []); + (Utils.eq_URI (), 0, 1, []); ty; term] ;; @@ -681,9 +764,10 @@ let relocate newmeta menv to_be_relocated = 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)) + (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 @@ -828,14 +912,14 @@ let meta_convertibility t1 t2 = exception TermIsNotAnEquality;; let term_is_equality term = - let iseq uri = UriManager.eq uri (LibraryObjects.eq_URI ()) in + let iseq uri = UriManager.eq uri (Utils.eq_URI ()) in match term with | Cic.Appl [Cic.MutInd (uri, _, _); _; _; _] when iseq uri -> true | _ -> false ;; let equality_of_term proof term = - let eq_uri = LibraryObjects.eq_URI () in + let eq_uri = Utils.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 -> @@ -867,7 +951,7 @@ let term_of_equality equality = 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 (Utils.eq_URI (), 0, []); ty; left; right]) in snd ( List.fold_right @@ -883,3 +967,24 @@ 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)) +;; +