X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=components%2Ftactics%2Fparamodulation%2Fsaturation.ml;h=fe63c7d669abed002c73b8876b60bba5abd0f834;hb=b09b0e4b30c429d8e050150cc4e9b94d7c205368;hp=8a31d6253430959c17f62fe5f23352a6e84db9f3;hpb=8c8932ee32a0d49dfe64f0542b5725037648e425;p=helm.git diff --git a/components/tactics/paramodulation/saturation.ml b/components/tactics/paramodulation/saturation.ml index 8a31d6253..fe63c7d66 100644 --- a/components/tactics/paramodulation/saturation.ml +++ b/components/tactics/paramodulation/saturation.ml @@ -23,9 +23,9 @@ * http://cs.unibo.it/helm/. *) -(* $Id$ *) +let _profiler = <:profiler<_profiler>>;; -(* <:profiler<"saturation">> *) +(* $Id$ *) open Inference;; open Utils;; @@ -73,7 +73,7 @@ let maxdepth = ref 3;; let maxwidth = ref 3;; type new_proof = - Equality.goal_proof * Equality.proof * Subst.substitution * Cic.metasenv + Equality.goal_proof * Equality.proof * int * Subst.substitution * Cic.metasenv type result = | ParamodulationFailure of string | ParamodulationSuccess of new_proof @@ -106,7 +106,7 @@ module OrderedEquality = struct let compare eq1 eq2 = match Equality.meta_convertibility_eq eq1 eq2 with | true -> 0 - | false -> + | false -> let w1, _, (ty,left, right, _), m1,_ = Equality.open_equality eq1 in let w2, _, (ty',left', right', _), m2,_ = Equality.open_equality eq2 in match Pervasives.compare w1 w2 with @@ -342,8 +342,14 @@ let infer env current (active_list, active_table) = (ignore(Indexing.check_target c current "infer1"); ignore(List.map (function current -> Indexing.check_target c current "infer2") active_list)); let new_pos = - let maxm, res = - Indexing.superposition_right !maxmeta env active_table current in + let maxm, copy_of_current = Equality.fix_metas !maxmeta current in + maxmeta := maxm; + let active_table = Indexing.index active_table copy_of_current in + let _ = <:start> in + let maxm, res = + Indexing.superposition_right !maxmeta env active_table current + in + let _ = <:stop> in if Utils.debug_metas then ignore(List.map (function current -> @@ -353,7 +359,8 @@ let infer env current (active_list, active_table) = | [] -> [] | equality::tl -> let maxm, res = - Indexing.superposition_right !maxmeta env table equality in + Indexing.superposition_right ~subterms_only:true !maxmeta env table equality + in maxmeta := maxm; if Utils.debug_metas then ignore @@ -363,16 +370,19 @@ let infer env current (active_list, active_table) = let pos = infer_positive table tl in res @ pos in +(* let maxm, copy_of_current = Equality.fix_metas !maxmeta current in maxmeta := maxm; +*) let curr_table = Indexing.index Indexing.empty current in - let pos = infer_positive curr_table (copy_of_current::active_list) - in + let _ = <:start> in + let pos = infer_positive curr_table ((*copy_of_current::*)active_list) in + let _ = <:stop> in if Utils.debug_metas then ignore(List.map (function current -> Indexing.check_target c current "sup3") pos); - res @ pos + res @ pos in derived_clauses := !derived_clauses + (List.length new_pos); match !maximal_retained_equality with @@ -389,41 +399,17 @@ let infer env current (active_list, active_table) = let check_for_deep_subsumption env active_table eq = let _,_,(eq_ty, left, right, order),metas,id = Equality.open_equality eq in - if id = 14242 then assert false; - let check_subsumed deep l r = let eqtmp = Equality.mk_tmp_equality(0,(eq_ty,l,r,Utils.Incomparable),metas)in match Indexing.subsumption env active_table eqtmp with | None -> false - | Some (s,eq') -> -(* - prerr_endline - ("\n\n " ^ Equality.string_of_equality ~env eq ^ - "\nis"^(if deep then " CONTEXTUALLY " else " ")^"subsumed by \n " ^ - Equality.string_of_equality ~env eq' ^ "\n\n"); -*) - true + | Some _ -> true in let rec aux b (ok_so_far, subsumption_used) t1 t2 = match t1,t2 with | t1, t2 when not ok_so_far -> ok_so_far, subsumption_used | t1, t2 when subsumption_used -> t1 = t2, subsumption_used -(* VERSIONE ERRATA - | Cic.Appl (h1::l),Cic.Appl (h2::l') when h1 = h2 -> - let rc = check_subsumed b t1 t1 in - if rc then - true, true - else if h1 = h2 then - (try - List.fold_left2 - (fun (ok_so_far, subsumption_used) t t' -> - aux true (ok_so_far, subsumption_used) t t') - (ok_so_far, subsumption_used) l l' - with Invalid_argument _ -> false,subsumption_used) - else - false, subsumption_used - | _ -> false, subsumption_used *) | Cic.Appl (h1::l),Cic.Appl (h2::l') -> let rc = check_subsumed b t1 t2 in if rc then @@ -442,20 +428,6 @@ let check_for_deep_subsumption env active_table eq = fst (aux false (true,false) left right) ;; -(* -let check_for_deep env active_table eq = - match Indexing.subsumption env active_table eq with - | None -> false - | Some _ -> true -;; -*) - -let profiler = HExtlib.profile "check_for_deep";; - -let check_for_deep_subsumption env active_table eq = - profiler.HExtlib.profile (check_for_deep_subsumption env active_table) eq -;; - (* buttare via sign *) (** simplifies current using active and passive *) @@ -471,17 +443,7 @@ let forward_simplify env (sign,current) ?passive (active_list, active_table) = Indexing.demodulation_equality !maxmeta env table sign current in maxmeta := newmeta; if Equality.is_identity env newcurrent then -(* debug_print *) -(* (lazy *) -(* (Printf.sprintf "\ncurrent was: %s\nnewcurrent is: %s\n" *) -(* (string_of_equality current) *) -(* (string_of_equality newcurrent))); *) -(* debug_print *) -(* (lazy *) -(* (Printf.sprintf "active is: %s" *) -(* (String.concat "\n" *) -(* (List.map (fun (_, e) -> (string_of_equality e)) active_list)))); *) - None + None else Some newcurrent in @@ -533,7 +495,7 @@ let forward_simplify env (sign,current) ?passive (active_list, active_table) = (* if Indexing.subsumption env active_table c = None then*) (match Indexing.subsumption env passive_table c with | None -> res - | Some (_,c') -> + | Some (_,c',_) -> None (*prerr_endline "\n\nPESCO DALLE PASSIVE LA PIU' GENERALE\n\n"; Some c'*)) @@ -543,15 +505,6 @@ let forward_simplify env (sign,current) ?passive (active_list, active_table) = *) ;; -type fs_time_info_t = { - mutable build_all: float; - mutable demodulate: float; - mutable subsumption: float; -};; - -let fs_time_info = { build_all = 0.; demodulate = 0.; subsumption = 0. };; - - (** simplifies new using active and passive *) let forward_simplify_new env new_pos ?passive active = if Utils.debug_metas then @@ -561,37 +514,27 @@ let forward_simplify_new env new_pos ?passive active = (fun current -> Indexing.check_target c current "forward new pos") new_pos;) end; - let t1 = Unix.gettimeofday () in - let active_list, active_table = active in let passive_table = match passive with | None -> None | Some ((_, _), pt) -> Some pt in - let t2 = Unix.gettimeofday () in - fs_time_info.build_all <- fs_time_info.build_all +. (t2 -. t1); - let demodulate sign table target = let newmeta, newtarget = Indexing.demodulation_equality !maxmeta env table sign target in maxmeta := newmeta; newtarget in - let t1 = Unix.gettimeofday () in (* we could also demodulate using passive. Currently we don't *) let new_pos = List.map (demodulate Positive active_table) new_pos in - let t2 = Unix.gettimeofday () in - fs_time_info.demodulate <- fs_time_info.demodulate +. (t2 -. t1); - let new_pos_set = List.fold_left (fun s e -> if not (Equality.is_identity env e) then - if EqualitySet.mem e s then s - else EqualitySet.add e s + EqualitySet.add e s else s) EqualitySet.empty new_pos in @@ -605,9 +548,6 @@ let forward_simplify_new env new_pos ?passive active = (fun e -> ((Indexing.subsumption env active_table e = None) && (Indexing.subsumption env passive_table e = None))) in -(* let t1 = Unix.gettimeofday () in *) -(* let t2 = Unix.gettimeofday () in *) -(* fs_time_info.subsumption <- fs_time_info.subsumption +. (t2 -. t1); *) let is_duplicate = match passive_table with | None -> @@ -617,7 +557,7 @@ let forward_simplify_new env new_pos ?passive active = not ((Indexing.in_index active_table e) || (Indexing.in_index passive_table e))) in - List.filter subs (List.filter is_duplicate new_pos) + List.filter subs (List.filter is_duplicate new_pos) ;; @@ -768,7 +708,6 @@ let backward_simplify env new' ?passive active = active, passive, newa, newp *) ;; - let close env new' given = let new_pos, new_table, min_weight = List.fold_left @@ -941,23 +880,34 @@ let print_goals goals = in Printf.sprintf "%d: %s" d (String.concat "; " gl')) goals)) ;; - + let check_if_goal_is_subsumed ((_,ctx,_) as env) table (goalproof,menv,ty) = -(* let names = names_of_context ctx in*) -(* Printf.eprintf "check_goal_subsumed: %s\n" (CicPp.pp ty names);*) +(* + let names = names_of_context ctx in + Printf.eprintf "check_goal_subsumed: %s\n" (CicPp.pp ty names); +*) match ty with | Cic.Appl[Cic.MutInd(uri,_,_);eq_ty;left;right] - when UriManager.eq uri (LibraryObjects.eq_URI ()) -> + when UriManager.eq uri (Utils.eq_URI ()) -> (let goal_equation = Equality.mk_equality (0,Equality.Exact (Cic.Implicit None),(eq_ty,left,right,Eq),menv) in (* match Indexing.subsumption env table goal_equation with*) match Indexing.unification env table goal_equation with - | Some (subst, equality ) -> + | Some (subst, equality, swapped ) -> + prerr_endline + ("GOAL SUBSUMED BY: " ^ Equality.string_of_equality equality); + prerr_endline ("SUBST:" ^ Subst.ppsubst subst); let (_,p,(ty,l,r,_),m,id) = Equality.open_equality equality in let cicmenv = Subst.apply_subst_metasenv subst (m @ menv) in - Some (goalproof, p, subst, cicmenv) + let p = + if swapped then + Equality.symmetric eq_ty l id uri m + else + p + in + Some (goalproof, p, id, subst, cicmenv) | None -> None) | _ -> None ;; @@ -995,12 +945,12 @@ let rec given_clause_fullred dbd env goals theorems ~passive active = (* in *) let ok, proof = (* apply_goal_to_theorems dbd env theorems ~passive active goals in *) - let iseq uri = UriManager.eq uri (LibraryObjects.eq_URI ()) in + let iseq uri = UriManager.eq uri (Utils.eq_URI ()) in match fst goals with | (goalproof,m,Cic.Appl[Cic.MutInd(uri,_,ens);eq_ty;left;right])::_ when left = right && iseq uri -> let reflproof = Equality.Exact (Equality.refl_proof eq_ty left) in - true, Some (goalproof, reflproof, Subst.empty_subst,m) + true, Some (goalproof, reflproof, 0, Subst.empty_subst,m) | goal::_ -> (match check_if_goal_is_subsumed env (snd active) goal with | None -> false,None @@ -1244,13 +1194,24 @@ let given_clause_fullred dbd env goals theorems passive active = (given_clause_fullred dbd env goals theorems passive) active *) -let iseq uri = UriManager.eq uri (LibraryObjects.eq_URI ());; +let iseq uri = UriManager.eq uri (Utils.eq_URI ());; let check_if_goal_is_identity env = function | (goalproof,m,Cic.Appl[Cic.MutInd(uri,_,ens);eq_ty;left;right]) when left = right && iseq uri -> let reflproof = Equality.Exact (Equality.refl_proof eq_ty left) in - Some (goalproof, reflproof,Subst.empty_subst,m) + Some (goalproof, reflproof, 0, Subst.empty_subst,m) + | (goalproof,m,Cic.Appl[Cic.MutInd(uri,_,ens);eq_ty;left;right]) + when iseq uri -> + (let _,context,_ = env in + try + let s,m,_ = + Inference.unification m m context left right CicUniv.empty_ugraph + in + let reflproof = Equality.Exact (Equality.refl_proof eq_ty left) in + let m = Subst.apply_subst_metasenv s m in + Some (goalproof, reflproof, 0, s,m) + with _ -> None) | _ -> None ;; @@ -1272,6 +1233,7 @@ let simplify_goal_set env goals passive active = (fun acc goal -> match simplify_goal env goal ~passive active with | _, g -> if find g acc then acc else g::acc) + (* active_goals active_goals *) [] active_goals in if List.length active_goals <> List.length simplified then @@ -1309,9 +1271,6 @@ let infer_goal_set env active goals = let selected = hd in let passive_goals = tl in let new' = Indexing.superposition_left env (snd active) selected in - let metasenv, context, ugraph = env in - let names = names_of_context context in - List.iter (fun (_,_,x) -> prerr_endline ("X: " ^ CicPp.pp x names)) new'; selected::active_goals, passive_goals @ new' | _::tl -> aux tl in @@ -1321,10 +1280,16 @@ let infer_goal_set env active goals = let infer_goal_set_with_current env current goals = let active_goals, passive_goals = goals in let _,table,_ = build_table [current] in + let _,_,_,_,id = Equality.open_equality current in active_goals, List.fold_left (fun acc g -> let new' = Indexing.superposition_left env table g in + if id = 2 then + begin + prerr_endline "XXXXXXX"; + List.iter (fun _,_,e -> prerr_endline (CicPp.ppterm e)) new' ; + end; acc @ new') passive_goals active_goals ;; @@ -1339,6 +1304,7 @@ let size_of_goal_set_p (_,l) = List.length l;; let given_clause ((_,context,_) as env) goals theorems passive active max_iterations max_time = + let names = names_of_context context in let initial_time = Unix.gettimeofday () in let iterations_left iterno = let now = Unix.gettimeofday () in @@ -1356,11 +1322,16 @@ let given_clause else if Unix.gettimeofday () > max_time then (ParamodulationFailure "No more time to spend") else + let _ = prerr_endline "simpl goal with active" in + let _ = <:start> in let goals = simplify_goal_set env goals passive active in + let _ = <:stop> in match check_if_goals_set_is_solved env active goals with | Some p -> - Printf.eprintf "Found a proof in: %f\n" - (Unix.gettimeofday() -. initial_time); + prerr_endline + (Printf.sprintf "Found a proof in: %f\n" + (Unix.gettimeofday() -. initial_time)); +(* assert false;*) ParamodulationSuccess p | None -> prerr_endline @@ -1382,38 +1353,44 @@ let given_clause kept_clauses := (size_of_passive passive) + (size_of_active active); (* SELECTION *) if passive_is_empty passive then - ParamodulationFailure "No more passive" (* maybe this is a success! *) + ParamodulationFailure "No more passive"(*maybe this is a success! *) else begin + let goals = infer_goal_set env active goals in + let goals = infer_goal_set env active goals in let goals = infer_goal_set env active goals in let current, passive = select env goals passive in - Printf.eprintf "Selected = %s\n" - (Equality.string_of_equality ~env current); + let _,_,goaltype = List.hd (fst goals) in + prerr_endline (Printf.sprintf "Current goal = %s\n" + (CicPp.pp goaltype names)); + prerr_endline (Printf.sprintf "Selected = %s\n" + (Equality.string_of_equality ~env current)); (* SIMPLIFICATION OF CURRENT *) let res = - forward_simplify env (Positive, current) ~passive active + forward_simplify env (Positive, current) (*~passive*) active in match res with | None -> step goals theorems passive active (iterno+1) | Some current -> (* GENERATION OF NEW EQUATIONS *) + prerr_endline "infer"; let new' = infer env current active in + prerr_endline "infer goal"; let goals = infer_goal_set_with_current env current goals in let active = - if Equality.is_identity env current then - assert false - (* nonsense code, check to se if it can be removed *) - else let al, tbl = active in al @ [current], Indexing.index tbl current in (* FORWARD AND BACKWARD SIMPLIFICATION *) + prerr_endline "fwd/back simpl"; let rec simplify new' active passive = let new' = forward_simplify_new env new' ~passive active in let active, passive, newa, retained, pruned = backward_simplify env new' ~passive active in - let passive = List.fold_left filter_dependent passive pruned in + let passive = + List.fold_left filter_dependent passive pruned + in match newa, retained with | None, None -> active, passive, new' | Some p, None @@ -1421,9 +1398,21 @@ let given_clause | Some p, Some rp -> simplify (new' @ p @ rp) active passive in let active, passive, new' = simplify new' active passive in + if iterno = 36 || iterno = 654 then + begin + prerr_endline "..................."; + List.iter + (fun x -> prerr_endline (Equality.string_of_equality +~env:env x)) new'; + prerr_endline "FINE..................."; + end; + prerr_endline "simpl goal with new"; let goals = let a,b,_ = build_table new' in + let _ = <:start> in + <:stop> in let passive = add_to_passive passive new' in step goals theorems passive active (iterno+1) @@ -1691,7 +1680,7 @@ let saturate let eq_indexes, equalities, maxm = find_equalities context proof in let ugraph = CicUniv.empty_ugraph in let env = (metasenv, context, ugraph) in - let goal = [], metasenv, type_of_goal in + let goal = [], List.filter (fun (i,_,_)->i<>goalno) metasenv, type_of_goal in let res, time = let t1 = Unix.gettimeofday () in let lib_eq_uris, library_equalities, maxm = @@ -1712,7 +1701,7 @@ let saturate context_hyp @ thms, [] else let refl_equal = - let us = UriManager.string_of_uri (LibraryObjects.eq_URI ()) in + let us = UriManager.string_of_uri (Utils.eq_URI ()) in UriManager.uri_of_string (us ^ "#xpointer(1/1/1)") in let t = CicUtil.term_of_uri refl_equal in @@ -1745,8 +1734,8 @@ let saturate given_clause_fullred dbd env goals theorems passive active *) let goals = make_goal_set goal in - let max_iterations = 1000 in - let max_time = Unix.gettimeofday () +. 600. (* minutes *) in + let max_iterations = 10000 in + let max_time = Unix.gettimeofday () +. 300. (* minutes *) in given_clause env goals theorems passive active max_iterations max_time in let finish = Unix.gettimeofday () in @@ -1756,9 +1745,12 @@ let saturate | ParamodulationFailure s -> raise (ProofEngineTypes.Fail (lazy ("NO proof found: " ^ s))) | ParamodulationSuccess - (goalproof,newproof,subsumption_subst, proof_menv) -> + (goalproof,newproof,subsumption_id,subsumption_subst, proof_menv) -> prerr_endline "OK, found a proof!"; - prerr_endline (Equality.pp_proof names goalproof newproof); + prerr_endline + (Equality.pp_proof names goalproof newproof subsumption_subst + subsumption_id type_of_goal); + prerr_endline (CicMetaSubst.ppmetasenv [] proof_menv); prerr_endline "ENDOFPROOFS"; (* generation of the CIC proof *) let side_effects = @@ -1766,16 +1758,15 @@ let saturate (ProofEngineHelpers.compare_metasenvs ~newmetasenv:metasenv ~oldmetasenv:proof_menv) in - let free_metas = - List.filter (fun i -> i <> goalno) - (ProofEngineHelpers.compare_metasenvs - ~oldmetasenv:metasenv ~newmetasenv:proof_menv) - in let goal_proof, side_effects_t = - let initial = Equality.build_proof_term newproof in + let initial = Equality.add_subst subsumption_subst newproof in Equality.build_goal_proof goalproof initial type_of_goal side_effects in let goal_proof = Subst.apply_subst subsumption_subst goal_proof in + let metas_still_open_in_proof = Utils.metas_of_term goal_proof in +(*prerr_endline (CicPp.pp goal_proof names);*) + (* ?? *) + let goal_proof = (* Subst.apply_subst subsumption_subst *) goal_proof in let side_effects_t = List.map (Subst.apply_subst subsumption_subst) side_effects_t in @@ -1791,16 +1782,29 @@ let saturate | None -> [i,context,ty], (Cic.Meta(i,[]))::acc2, (Cic.Meta(i,irl)) ::acc3,Some (Cic.Meta(i,irl))) - ([],[],[],None) proof_menv + ([],[],[],None) + (List.filter + (fun (i,_,_) -> List.mem i metas_still_open_in_proof) + proof_menv) in let replace where = + (* we need this fake equality since the metas of the hypothesis may be + * with a real local context *) ProofEngineReduction.replace_lifting - ~equality:(=) ~what ~with_what ~where + ~equality:(fun x y -> + match x,y with Cic.Meta(i,_),Cic.Meta(j,_) -> i=j | _-> false) + ~what ~with_what ~where in let goal_proof = replace goal_proof in (* ok per le meta libere... ma per quelle che c'erano e sono rimaste? * what mi pare buono, sostituisce solo le meta farlocche *) let side_effects_t = List.map replace side_effects_t in + let free_metas = + List.filter (fun i -> i <> goalno) + (ProofEngineHelpers.compare_metasenvs + ~oldmetasenv:metasenv ~newmetasenv:goal_proof_menv) + in +prerr_endline ("freemetas: " ^ String.concat "," (List.map string_of_int free_metas) ); (* check/refine/... build the new proof *) let replaced_goal = ProofEngineReduction.replace @@ -1825,19 +1829,27 @@ let saturate let final_subst = (goalno,(context,goal_proof,type_of_goal))::subst_side_effects in +prerr_endline ("MENVreal_menv: " ^ CicMetaSubst.ppmetasenv [] real_menv); let _ = - let ty,_ = + try CicTypeChecker.type_of_aux' real_menv context goal_proof CicUniv.empty_ugraph - in - ty + with + | CicUtil.Meta_not_found _ + | CicTypeChecker.TypeCheckerFailure _ + | CicTypeChecker.AssertFailure _ + | Invalid_argument "list_fold_left2" as exn -> + prerr_endline "THE PROOF DOES NOT TYPECHECK!"; + prerr_endline (CicPp.pp goal_proof names); + prerr_endline "THE PROOF DOES NOT TYPECHECK!"; + raise exn in let proof, real_metasenv = ProofEngineHelpers.subst_meta_and_metasenv_in_proof proof goalno (CicMetaSubst.apply_subst final_subst) real_menv in let open_goals = - match free_meta with Some (Cic.Meta (m,_)) -> [m] | _ -> [] + match free_meta with Some(Cic.Meta(m,_)) when m<>goalno ->[m] | _ ->[] in Printf.eprintf "GOALS APERTI: %s\nMETASENV PRIMA:\n%s\nMETASENV DOPO:\n%s\n" @@ -2032,7 +2044,7 @@ let demodulate_tac ~dbd ~pattern ((proof,goal)(*s initialstatus*)) = in if changed then begin - let opengoal = Cic.Meta(maxm,irl) in + let opengoal = Equality.Exact (Cic.Meta(maxm,irl)) in let proofterm,_ = Equality.build_goal_proof newproof opengoal ty [] in let extended_metasenv = (maxm,context,newty)::metasenv in @@ -2054,3 +2066,7 @@ let demodulate_tac ~dbd ~pattern ((proof,goal)(*s initialstatus*)) = let demodulate_tac ~dbd ~pattern = ProofEngineTypes.mk_tactic (demodulate_tac ~dbd ~pattern) ;; + +let get_stats () = + <:show> ^ Indexing.get_stats () ^ Inference.get_stats ();; +