X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=components%2Ftactics%2Fparamodulation%2Fsaturation.ml;h=351bc11bd0b88f67def8add7000da426cb418c4a;hb=be69d5604639ffb64ca56fcbf0a9d4afa97c6c41;hp=59b06ef2986e711d900a81d1588773b1df868d96;hpb=ba2372bd35aec412f5a7b61e5431236505567c43;p=helm.git diff --git a/components/tactics/paramodulation/saturation.ml b/components/tactics/paramodulation/saturation.ml index 59b06ef29..351bc11bd 100644 --- a/components/tactics/paramodulation/saturation.ml +++ b/components/tactics/paramodulation/saturation.ml @@ -25,6 +25,8 @@ (* $Id$ *) +(* <:profiler<"saturation">> *) + open Inference;; open Utils;; @@ -71,14 +73,13 @@ let maxdepth = ref 3;; let maxwidth = ref 3;; type new_proof = - Equality.goal_proof * Equality.new_proof * Equality.substitution * Cic.metasenv -type old_proof = Equality.old_proof * Cic.metasenv + Equality.goal_proof * Equality.proof * Subst.substitution * Cic.metasenv type result = - | ParamodulationFailure - | ParamodulationSuccess of (new_proof * old_proof) option + | ParamodulationFailure of string + | ParamodulationSuccess of new_proof ;; -type goal = (Equality.goal_proof * Equality.old_proof) * Cic.metasenv * Cic.term;; +type goal = Equality.goal_proof * Cic.metasenv * Cic.term;; type theorem = Cic.term * Cic.term * Cic.metasenv;; @@ -111,7 +112,8 @@ module OrderedEquality = struct match Pervasives.compare w1 w2 with | 0 -> let res = (List.length m1) - (List.length m2) in - if res <> 0 then res else Pervasives.compare eq1 eq2 + if res <> 0 then res else + Equality.compare eq1 eq2 | res -> res end @@ -152,12 +154,22 @@ let rec select env goals passive = match !weight_age_counter with | 0 -> ( weight_age_counter := !weight_age_ratio; - match pos_list with - | (hd:EqualitySet.elt)::tl -> - let passive_table = - Indexing.remove_index passive_table hd - in hd, ((tl, EqualitySet.remove hd pos_set), passive_table) - | _ -> assert false) + let rec skip_giant pos_list pos_set passive_table = + match pos_list with + | (hd:EqualitySet.elt)::tl -> + let w,_,_,_,_ = Equality.open_equality hd in + let passive_table = + Indexing.remove_index passive_table hd + in + let pos_set = EqualitySet.remove hd pos_set in + if w < 500 then + hd, ((tl, pos_set), passive_table) + else + (prerr_endline ("\n\n\nGIANT SKIPPED: "^string_of_int w^"\n\n\n"); + skip_giant tl pos_set passive_table) + | _ -> assert false + in + skip_giant pos_list pos_set passive_table) | _ when (!symbols_counter > 0) -> (symbols_counter := !symbols_counter - 1; let cardinality map = @@ -210,6 +222,28 @@ let rec select env goals passive = passive_table) ;; +let filter_dependent passive id = + prerr_endline ("+++++++++++++++passives "^ + ( string_of_int (size_of_passive passive))); + let (pos_list, pos_set), passive_table = passive in + let passive = + List.fold_right + (fun eq ((list,set),table) -> + if Equality.depend eq id then + (let _,_,_,_,id_eq = Equality.open_equality eq in + if id_eq = 9228 then + prerr_endline ("\n\n--------filtering "^(string_of_int id_eq)); + ((list, + EqualitySet.remove eq set), + Indexing.remove_index table eq)) + else + ((eq::list, set),table)) + pos_list (([],pos_set),passive_table) in + prerr_endline ("+++++++++++++++passives "^ + ( string_of_int (size_of_passive passive))); + passive +;; + (* initializes the passive set of equalities *) let make_passive pos = @@ -353,6 +387,75 @@ let infer env current (active_list, active_table) = List.filter (fun e -> OrderedEquality.compare e eq <= 0) new_pos ;; +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 + 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 + 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 + in + 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 *) @@ -406,26 +509,38 @@ let forward_simplify env (sign,current) ?passive (active_list, active_table) = match res with | None -> None | Some c -> - (* immagino non funzioni piu'... *) if Indexing.in_index active_table c then None else match passive_table with | None -> + if check_for_deep_subsumption env active_table c then + None + else + res +(* if Indexing.subsumption env active_table c = None then res else None +*) | Some passive_table -> if Indexing.in_index passive_table c then None else - if Indexing.subsumption env active_table c = None then - if Indexing.subsumption env passive_table c = None then - res - else - None + if check_for_deep_subsumption env active_table c then + None + else +(* if Indexing.subsumption env active_table c = None then*) + (match Indexing.subsumption env passive_table c with + | None -> res + | Some (_,c') -> + None + (*prerr_endline "\n\nPESCO DALLE PASSIVE LA PIU' GENERALE\n\n"; + Some c'*)) +(* else None +*) ;; type fs_time_info_t = { @@ -524,8 +639,8 @@ let rec simplify_goal env goal ?passive (active_list, active_table) = | None -> demodulate active_table goal | Some passive_table -> let changed, goal = demodulate active_table goal in - let changed', goal = demodulate passive_table goal in - (changed || changed'), goal +(* let changed', goal = demodulate passive_table goal in*) + (changed (*|| changed'*)), goal in changed, if not changed then @@ -564,45 +679,50 @@ let simplify_goals env goals ?passive active = (** simplifies active usign new *) let backward_simplify_active env new_pos new_table min_weight active = let active_list, active_table = active in - let active_list, newa = + let active_list, newa, pruned = List.fold_right - (fun equality (res, newn) -> - let ew, _, _, _,_ = Equality.open_equality equality in + (fun equality (res, newn,pruned) -> + let ew, _, _, _,id = Equality.open_equality equality in if ew < min_weight then - equality::res, newn + equality::res, newn,pruned else match forward_simplify env (Utils.Positive, equality) (new_pos, new_table) with - | None -> res, newn + | None -> res, newn, id::pruned | Some e -> if Equality.compare equality e = 0 then - e::res, newn + e::res, newn, pruned else - res, e::newn) - active_list ([], []) + res, e::newn, pruned) + active_list ([], [],[]) in let find eq1 where = List.exists (Equality.meta_convertibility_eq eq1) where in - let active, newa = + let id_of_eq eq = + let _, _, _, _,id = Equality.open_equality eq in id + in + let ((active1,pruned),tbl), newa = List.fold_right - (fun eq (res, tbl) -> + (fun eq ((res,pruned), tbl) -> if List.mem eq res then - res, tbl + (res, (id_of_eq eq)::pruned),tbl else if (Equality.is_identity env eq) || (find eq res) then ( - res, tbl + (res, (id_of_eq eq)::pruned),tbl ) else - eq::res, Indexing.index tbl eq) - active_list ([], Indexing.empty), + (eq::res,pruned), Indexing.index tbl eq) + active_list (([],pruned), Indexing.empty), List.fold_right (fun eq p -> if (Equality.is_identity env eq) then p else eq::p) newa [] in + if List.length active1 <> List.length (fst active) then + prerr_endline "\n\n\nMANCAVANO DELLE PRUNED!!!!\n\n\n"; match newa with - | [] -> active, None - | _ -> active, Some newa + | [] -> (active1,tbl), None, pruned + | _ -> (active1,tbl), Some newa, pruned ;; @@ -633,22 +753,32 @@ let backward_simplify_passive env new_pos new_table min_weight passive = | _ -> ((pl, ps), passive_table), Some (newp) ;; +let build_table equations = + List.fold_left + (fun (l, t, w) e -> + let ew, _, _, _ , _ = Equality.open_equality e in + e::l, Indexing.index t e, min ew w) + ([], Indexing.empty, 1000000) equations +;; + let backward_simplify env new' ?passive active = - let new_pos, new_table, min_weight = + let new_pos, new_table, min_weight = build_table new' in +(* List.fold_left (fun (l, t, w) e -> let ew, _, _, _ , _ = Equality.open_equality e in e::l, Indexing.index t e, min ew w) ([], Indexing.empty, 1000000) new' in - let active, newa = +*) + let active, newa, pruned = backward_simplify_active env new_pos new_table min_weight active in match passive with | None -> - active, (make_passive []), newa, None + active, (make_passive []), newa, None, pruned | Some passive -> - active, passive, newa, None + active, passive, newa, None, pruned (* prova let passive, newp = backward_simplify_passive env new_pos new_table min_weight passive in @@ -826,42 +956,23 @@ let print_goals goals = Printf.sprintf "%d: %s" d (String.concat "; " gl')) goals)) ;; -let check_if_goal_is_subsumed env ((cicproof,proof),menv,ty) table = +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); match ty with | Cic.Appl[Cic.MutInd(uri,_,_);eq_ty;left;right] when UriManager.eq uri (LibraryObjects.eq_URI ()) -> (let goal_equation = Equality.mk_equality - (0,(Equality.Exact (Cic.Rel (-1)),proof),(eq_ty,left,right,Eq),menv) - in - match Indexing.subsumption env table goal_equation with - | Some (subst, equality ) -> - let (_,(np,p),(ty,l,r,_),m,id) = - Equality.open_equality equality in - let p = Equality.apply_subst subst - (Equality.build_proof_term_old p) in - let newp = - let rec repl = function - | Equality.ProofGoalBlock (_, gp) -> - Equality.ProofGoalBlock - (Equality.BasicProof (Equality.empty_subst,p), gp) - | Equality.NoProof -> - Equality.BasicProof (Equality.empty_subst,p) - | Equality.BasicProof _ -> - Equality.BasicProof (Equality.empty_subst,p) - | Equality.SubProof (t, i, p2) -> - Equality.SubProof (t, i, repl p2) - | _ -> assert false - in - repl proof - in - let newcicp,np,subst,cicmenv = - cicproof,np, subst, (m @ menv) - in - Some - ((newcicp,np,subst,cicmenv), - (newp, Equality.apply_subst_metasenv subst m @ menv )) - | None -> None) + (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 ) -> + 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) + | None -> None) | _ -> None ;; @@ -893,35 +1004,12 @@ let rec given_clause_fullred dbd env goals theorems ~passive active = (* apply_goal_to_theorems dbd env theorems ~passive active goals in *) let iseq uri = UriManager.eq uri (LibraryObjects.eq_URI ()) in match (fst goals) with - | (_, [proof, m, Cic.Appl[Cic.MutInd(uri,_,ens);eq_ty;left;right]])::_ + | (_,[goalproof,m,Cic.Appl[Cic.MutInd(uri,_,ens);eq_ty;left;right]])::_ when left = right && iseq uri -> - let p = - Cic.Appl [Cic.MutConstruct (* reflexivity *) - (LibraryObjects.eq_URI (), 0, 1, []);eq_ty; left] - in - let newp = - let rec repl = function - | Equality.ProofGoalBlock (_, gp) -> - Equality.ProofGoalBlock - (Equality.BasicProof (Equality.empty_subst,p), gp) - | Equality.NoProof -> - - Equality.BasicProof (Equality.empty_subst,p) - | Equality.BasicProof _ -> - Equality.BasicProof (Equality.empty_subst,p) - | Equality.SubProof (t, i, p2) -> - Equality.SubProof (t, i, repl p2) - | _ -> assert false - in - repl (snd proof) - in - let reflproof = Equality.refl_proof eq_ty left in - true, - Some ((fst proof,Equality.Exact reflproof, - Equality.empty_subst,m), - (newp,m)) - | (_, [proof,m,ty])::_ -> - (match check_if_goal_is_subsumed env (proof,m,ty) (snd active) with + let reflproof = Equality.Exact (Equality.refl_proof eq_ty left) in + true, Some (goalproof, reflproof, Subst.empty_subst,m) + | (_, [goal])::_ -> + (match check_if_goal_is_subsumed env (snd active) goal with | None -> false,None | Some p -> prerr_endline "Proof found by subsumption!"; @@ -944,7 +1032,9 @@ let rec given_clause_fullred dbd env goals theorems ~passive active = (let x,y,_ = passive in (fst x)@(fst y)))) in prerr_endline s; prerr_endline sp; *) - ParamodulationSuccess (proof)) + match proof with + | None -> assert false + | Some p -> ParamodulationSuccess p) else given_clause_fullred_aux dbd env goals theorems passive active else @@ -961,7 +1051,7 @@ let rec given_clause_fullred dbd env goals theorems ~passive active = (* else *) (* given_clause_fullred_aux env goals theorems passive active *) (* else *) - if (passive_is_empty passive) then ParamodulationFailure + if (passive_is_empty passive) then ParamodulationFailure "" else given_clause_fullred_aux dbd env goals theorems passive active and given_clause_fullred_aux dbd env goals theorems passive active = @@ -1029,7 +1119,7 @@ and given_clause_fullred_aux dbd env goals theorems passive active = kept_clauses := (size_of_passive passive) + (size_of_active active); match passive_is_empty passive with - | true -> ParamodulationFailure + | true -> ParamodulationFailure "" (* given_clause_fullred dbd env goals theorems passive active *) | false -> let current, passive = select env (fst goals) passive in @@ -1055,8 +1145,8 @@ and given_clause_fullred_aux dbd env goals theorems passive active = (* weight_age_counter := !weight_age_counter + 1; *) given_clause_fullred dbd env goals theorems passive active | Some current -> - prerr_endline (Printf.sprintf "selected sipl: %s" - (Equality.string_of_equality ~env current)); +(* prerr_endline (Printf.sprintf "selected simpl: %s" + (Equality.string_of_equality ~env current));*) let t1 = Unix.gettimeofday () in let new' = infer env current active in let _ = @@ -1083,8 +1173,10 @@ and given_clause_fullred_aux dbd env goals theorems passive active = forward_simpl_new_time := !forward_simpl_new_time +. (t2 -. t1); let t1 = Unix.gettimeofday () in - let active, passive, newa, retained = + let active, passive, newa, retained, pruned = backward_simplify env new' ~passive active in + let passive = + List.fold_left filter_dependent passive pruned in let t2 = Unix.gettimeofday () in backward_simpl_time := !backward_simpl_time +. (t2 -. t1); match newa, retained with @@ -1101,7 +1193,12 @@ and given_clause_fullred_aux dbd env goals theorems passive active = | Some p, Some rp -> simplify (new' @ p @ rp) active passive in - let active, _, new' = simplify new' active passive in + let active, passive, new' = simplify new' active passive in + let goals = + let a,b,_ = build_table new' in + simplify_goals env goals ~passive (a,b) + in + (* pessima prova let new1 = prova env new' active in let new' = (fst new') @ (fst new1), (snd new') @ (snd new1) in @@ -1154,6 +1251,154 @@ 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 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) + | _ -> None +;; + +let rec check goal = function + | [] -> None + | f::tl -> + match f goal with + | None -> check goal tl + | (Some p) as ok -> ok +;; + +let simplify_goal_set env goals passive active = + (* + let supl_goals = + (List.flatten + (List.map (Indexing.superposition_left env (snd active)) + goals)) + in + *) + let simplified = + HExtlib.filter_map + (fun g -> + match simplify_goal env g ~passive active with + | true, g -> Some g + | false, g -> Some g) + goals + in + HExtlib.list_uniq ~eq:(fun (_,_,t1) (_,_,t2) -> t1 = t2) + (List.sort (fun (_,_,t1) (_,_,t2) -> compare t1 t1) + ((*goals @*) simplified)) +;; + +let check_if_goals_set_is_solved env active goals = + List.fold_left + (fun proof goal -> + match proof with + | Some p -> proof + | None -> + check goal [ + check_if_goal_is_identity env; + check_if_goal_is_subsumed env (snd active)]) + None goals +;; + +let size_of_goal_set = List.length;; + +(** given-clause algorithm with full reduction strategy: NEW implementation *) +(* here goals is a set of goals in OR *) +let given_clause + ((_,context,_) as env) goals theorems passive active max_iterations max_time += + let initial_time = Unix.gettimeofday () in + let iterations_left iterno = + let now = Unix.gettimeofday () in + let time_left = max_time -. now in + let time_spent_until_now = now -. initial_time in + let iteration_medium_cost = + time_spent_until_now /. (float_of_int iterno) + in + let iterations_left = time_left /. iteration_medium_cost in + int_of_float iterations_left + in + let rec step goals theorems passive active iterno = + if iterno > max_iterations then + (ParamodulationFailure "No more iterations to spend") + else if Unix.gettimeofday () > max_time then + (ParamodulationFailure "No more time to spend") + else + let goals = simplify_goal_set env goals passive active 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); + ParamodulationSuccess p + | None -> + prerr_endline + (Printf.sprintf "%d #ACTIVES: %d #PASSIVES: %d #GOALSET: %d\n" + iterno (size_of_active active) (size_of_passive passive) + (size_of_goal_set goals)); + (* PRUNING OF PASSIVE THAT WILL NEVER BE PROCESSED *) + let passive = + let selection_estimate = iterations_left iterno in + let kept = size_of_passive passive in + if kept > selection_estimate then + begin + (*Printf.eprintf "Too many passive equalities: pruning..."; + prune_passive selection_estimate active*) passive + end + else + passive + in + 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! *) + else + begin + let current, passive = select env [1,goals] passive in + Printf.eprintf "Selected = %s\n" + (Equality.string_of_equality ~env current); + (* SIMPLIFICATION OF CURRENT *) + let res = + 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 *) + let new' = infer env current active 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 *) + 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 + match newa, retained with + | None, None -> active, passive, new' + | Some p, None + | None, Some p -> simplify (new' @ p) active passive + | Some p, Some rp -> simplify (new' @ p @ rp) active passive + in + let active, passive, new' = simplify new' active passive in + let goals = + let a,b,_ = build_table new' in + simplify_goal_set env goals passive (a,b) + in + let passive = add_to_passive passive new' in + step goals theorems passive active (iterno+1) + end + in + step goals theorems passive active 1 +;; let rec saturate_equations env goal accept_fun passive active = elapsed_time := Unix.gettimeofday () -. !start_time; @@ -1177,8 +1422,10 @@ let rec saturate_equations env goal accept_fun passive active = in let rec simplify new' active passive = let new' = forward_simplify_new env new' ~passive active in - let active, passive, newa, retained = + let active, passive, newa, retained, pruned = backward_simplify env new' ~passive active in + let passive = + List.fold_left filter_dependent passive pruned in match newa, retained with | None, None -> active, passive, new' | Some p, None @@ -1396,47 +1643,6 @@ let reset_refs () = Equality.reset (); ;; -let interactive_comparison context t1 t2 = - let rc = ref [] in - let module P = Printf in - let rec aux n context t1 t2 = -(* let names = names_of_context context in*) - let pp t1 t2 = () (* - P.eprintf "%s%s === %s\n" (String.make n ' ') - (CicPp.pp t1 names) (CicPp.pp t2 names) *) - in - match t1,t2 with - | _, Cic.Appl [Cic.Const(uri,_);t2] when - UriManager.eq uri (UriManager.uri_of_string - "cic:/Coq/Init/Logic/sym_eq.con")-> aux n context t1 t2 - | Cic.Implicit _, _ -> pp t1 t2 - | Cic.Meta (n,_), _ -> - rc := (n,t2,context) :: !rc; - pp (Cic.Meta(n,[])) t2 - | Cic.Rel n1, Cic.Rel n2 when n1 = n2 -> pp t1 t2 - | Cic.Appl l1,Cic.Appl l2 -> - if List.length l1 <> List.length l2 then - begin - prerr_endline "ERROR: application with diff num of args"; - pp t1 t2 - end - else - List.iter2 (aux (n+1) context) l1 l2 - | Cic.Lambda (name,s,t1),Cic.Lambda(_,_,t2) -> - let context = (Some (name,(Cic.Decl s)))::context in - aux (n+1) context t1 t2 - | Cic.Const (u1,_), Cic.Const (u2,_) when UriManager.eq u1 u2 -> - pp t1 t2 - | _,_ -> pp t1 t2 - in - aux 0 context t1 t2; - List.iter (fun (n,t,ctx) -> - let names = names_of_context ctx in - Printf.eprintf "%d := %s\n" n (CicPp.pp t names)) - (HExtlib.list_uniq (List.sort (fun (x,_,_) (y,_,_) -> x-y) !rc)) -;; - - let saturate dbd ?(full=false) ?(depth=default_depth) ?(width=default_width) status = let module C = Cic in @@ -1450,6 +1656,7 @@ let saturate let goal' = goal in let uri, metasenv, meta_proof, term_to_prove = proof in let _, context, goal = CicUtil.lookup_meta goal' metasenv in + let names = names_of_context context in let eq_indexes, equalities, maxm = find_equalities context proof in let new_meta_goal, metasenv, type_of_goal = let irl = @@ -1463,9 +1670,9 @@ let saturate in let ugraph = CicUniv.empty_ugraph in let env = (metasenv, context, ugraph) in - let goal = - ([],Equality.BasicProof (Equality.empty_subst,new_meta_goal)), [], goal - in + prerr_endline + ("METASENV DEL GOAL: " ^ CicMetaSubst.ppmetasenv [] metasenv ); + let goal = [], metasenv, goal in let res, time = let t1 = Unix.gettimeofday () in let lib_eq_uris, library_equalities, maxm = @@ -1514,203 +1721,176 @@ let saturate let passive = make_passive equalities in let start = Unix.gettimeofday () in let res = +(* let goals = make_goals goal in given_clause_fullred dbd env goals theorems passive active +*) + let goals = [goal] in + let max_iterations = 1000 in + let max_time = + Unix.gettimeofday () +. + 600. (* minutes *) + in + given_clause env goals theorems passive active max_iterations max_time in let finish = Unix.gettimeofday () in (res, finish -. start) in match res with + | ParamodulationFailure s -> + raise (ProofEngineTypes.Fail (lazy ("NO proof found: " ^ s))) | ParamodulationSuccess - (Some ((goalproof,newproof,subsumption_subst, newproof_menv),(proof, proof_menv))) -> + (goalproof,newproof,subsumption_subst, proof_menv) -> prerr_endline "OK, found a proof!"; - prerr_endline (Equality.string_of_proof_old proof); - - let cic_proof = Equality.build_proof_term_old proof in + + prerr_endline "NEWPROOF"; + (* prerr_endline (Equality.string_of_proof_new ~names newproof + * goalproof);*) + prerr_endline (Equality.pp_proof names goalproof newproof); + +(* assert false; *) - let cic_proof_new,cic_proof_new_menv = - Equality.build_goal_proof goalproof (Equality.build_proof_term_new newproof) + (* generation of the proof *) + let cic_proof_new = + Equality.build_goal_proof + goalproof (Equality.build_proof_term newproof) type_of_goal in - let newproof_menv = - Equality.apply_subst_metasenv subsumption_subst - (newproof_menv @ cic_proof_new_menv) + let cic_proof_new = + Subst.apply_subst subsumption_subst cic_proof_new in - let cic_proof_new = Equality.apply_subst subsumption_subst cic_proof_new in + (* replacing fake mets with real ones *) let equality_for_replace i t1 = match t1 with | C.Meta (n, _) -> n = i | _ -> false in let mkirl = CicMkImplicit.identity_relocation_list_for_metavariable in - prerr_endline "replacing metas (old)"; - let proof_menv, what, with_what = - let irl = mkirl context in - List.fold_left - (fun (acc1,acc2,acc3) (i,_,ty) -> - (i,context,ty)::acc1, - (Cic.Meta(i,[]))::acc2, - (Cic.Meta(i,irl)) ::acc3) - ([],[],[]) proof_menv - in - let cic_proof = ProofEngineReduction.replace_lifting - ~equality:(=) - ~what ~with_what - ~where:cic_proof - in prerr_endline "replacing metas (new)"; - let newproof_menv, what, with_what = + let newproof_menv, what, with_what,_ = let irl = mkirl context in List.fold_left - (fun (acc1,acc2,acc3) (i,_,ty) -> - (i,context,ty)::acc1, - (Cic.Meta(i,[]))::acc2, - (Cic.Meta(i,irl)) ::acc3) - ([],[],[]) newproof_menv + (fun (acc1,acc2,acc3,uniq) (i,_,ty) -> + match uniq with + | Some m -> + acc1, + (Cic.Meta(i,[]))::acc2, + m::acc3, uniq + | None -> + [i,context,ty], + (Cic.Meta(i,[]))::acc2, + (Cic.Meta(i,irl)) ::acc3,Some (Cic.Meta(i,irl))) + ([],[],[],None) proof_menv in let cic_proof_new = ProofEngineReduction.replace_lifting ~equality:(=) ~what ~with_what ~where:cic_proof_new in - let names = names_of_context context in - prerr_endline "OLDPROOF"; - prerr_endline (Equality.string_of_proof_old proof); - prerr_endline "OLDPROOFCIC"; - prerr_endline (CicPp.pp cic_proof names); - prerr_endline "NEWPROOF"; - prerr_endline (Equality.string_of_proof_new ~names newproof goalproof); - prerr_endline "NEWPROOFCIC"; - prerr_endline (CicPp.pp cic_proof_new names); - let newmetasenv = + + (* pp new/old proof *) +(* prerr_endline "NEWPROOFCIC";*) +(* prerr_endline (CicPp.pp cic_proof_new names); *) + + (* generation of proof metasenv *) + let newmetasenv_new = metasenv@newproof_menv in + let newmetasenv_new = let i1 = match new_meta_goal with | C.Meta (i, _) -> i | _ -> assert false in - List.filter (fun (i, _, _) -> i <> i1 && i <> goal') metasenv + List.filter (fun (i, _, _) -> i <> i1 && i <> goal') newmetasenv_new in - let newmetasenv = newmetasenv@proof_menv in - let newmetasenv_new = newmetasenv@newproof_menv in + (* check/refine/... build the new proof *) let newstatus = - try - let cic_proof,newmetasenv,proof_menv,ty, ug = - prerr_endline "type checking ... (old) "; -(* let old_ty, oldug = *) -(* CicTypeChecker.type_of_aux' newmetasenv context cic_proof ugraph *) -(* in*) - let cic_proof_new,new_ty,newmetasenv_new,newug = - try - (* - prerr_endline "refining ... (new) "; - CicRefine.type_of_aux' - newmetasenv_new context cic_proof_new ugraph*) - let ty,ug = - prerr_endline "typechecking ... (new) "; - CicTypeChecker.type_of_aux' - newmetasenv_new context cic_proof_new ugraph - in - cic_proof_new, ty, newmetasenv_new, ug - with - | CicTypeChecker.TypeCheckerFailure s -> - prerr_endline "FAILURE IN TYPECHECKING"; - prerr_endline (Lazy.force s); - assert false - | CicRefine.RefineFailure s - | CicRefine.Uncertain s - | CicRefine.AssertFailure s -> - prerr_endline "FAILURE IN REFINE"; - prerr_endline (Lazy.force s); - interactive_comparison context cic_proof_new cic_proof; - assert false - in -(* - prerr_endline "check unif ... (old vs new) "; - (try - ignore(CicUnification.fo_unif - newmetasenv_new context cic_proof_new cic_proof CicUniv.empty_ugraph) - with CicUnification.UnificationFailure _ -> - prerr_endline "WARNING, new and old proofs are not unifiable"); - prerr_endline "unif ... (new) "; - let subst, newmetasenv_new, newug = - CicUnification.fo_unif - newmetasenv_new context new_ty type_of_goal newug - in - if subst <> [] then - prerr_endline "UNIF SERVE ################################"; -*) - let subst = [] in - if List.length newmetasenv_new <> 0 then - prerr_endline - ("Some METAS are still open: " ^ CicMetaSubst.ppmetasenv - [] newmetasenv_new); - (CicMetaSubst.apply_subst subst cic_proof_new), - newmetasenv_new, - (CicMetaSubst.apply_subst_metasenv subst newmetasenv_new), - (CicMetaSubst.apply_subst subst new_ty), - newug -(* cic_proof,newmetasenv,proof_menv,oldty,oldug*) - in - prerr_endline "FINAL PROOF"; - prerr_endline (CicPp.pp cic_proof names); - prerr_endline "ENDOFPROOFS"; - - debug_print - (lazy - (Printf.sprintf - "\nGOAL was: %s\nPROOF has type: %s\nconvertible?: %s\n" - (CicPp.pp type_of_goal names) (CicPp.pp ty names) - (string_of_bool - (fst (CicReduction.are_convertible - context type_of_goal ty ug))))); - let real_proof = - ProofEngineReduction.replace - ~equality:equality_for_replace - ~what:[goal'] ~with_what:[cic_proof] - ~where:meta_proof + let cic_proof,newmetasenv,proof_menv,ty, ug = + let cic_proof_new,new_ty,newmetasenv_new,newug = + try + (* + prerr_endline "refining ... (new) "; + CicRefine.type_of_aux' + newmetasenv_new context cic_proof_new ugraph + *) + let ty,ug = + prerr_endline "typechecking ... (new) "; + CicTypeChecker.type_of_aux' + newmetasenv_new context cic_proof_new ugraph + in + cic_proof_new, ty, newmetasenv_new, ug + with + | CicTypeChecker.TypeCheckerFailure s -> + prerr_endline "THE PROOF DOESN'T TYPECHECK!!!"; + prerr_endline (Lazy.force s); + assert false + | CicRefine.RefineFailure s + | CicRefine.Uncertain s + | CicRefine.AssertFailure s -> + prerr_endline "FAILURE IN REFINE"; + prerr_endline (Lazy.force s); + assert false in - debug_print - (lazy - (Printf.sprintf "status:\n%s\n%s\n%s\n%s\n" - (match uri with Some uri -> UriManager.string_of_uri uri - | None -> "") - (print_metasenv newmetasenv) - (CicPp.pp real_proof [](* names *)) - (CicPp.pp term_to_prove names))); - ((uri, newmetasenv, real_proof, term_to_prove), - List.map (fun (i,_,_) -> i) proof_menv) - with CicTypeChecker.TypeCheckerFailure _ -> - debug_print (lazy "THE PROOF DOESN'T TYPECHECK!!!"); - debug_print (lazy (CicPp.pp cic_proof names)); - raise (ProofEngineTypes.Fail - (lazy "Found a proof, but it doesn't typecheck")) + if List.length newmetasenv_new <> 0 then + prerr_endline + ("Some METAS are still open: "(* ^ CicMetaSubst.ppmetasenv + [] newmetasenv_new*)); + cic_proof_new, newmetasenv_new, newmetasenv_new,new_ty, newug + (* THE OLD PROOF: cic_proof,newmetasenv,proof_menv,oldty,oldug *) + in + prerr_endline "FINAL PROOF"; + prerr_endline (CicPp.pp cic_proof names); + prerr_endline "ENDOFPROOFS"; + (* + debug_print + (lazy + (Printf.sprintf + "\nGOAL was: %s\nPROOF has type: %s\nconvertible?: %s\n" + (CicPp.pp type_of_goal names) (CicPp.pp ty names) + (string_of_bool + (fst (CicReduction.are_convertible + context type_of_goal ty ug))))); + *) + let real_proof = + ProofEngineReduction.replace + ~equality:equality_for_replace + ~what:[goal'] ~with_what:[cic_proof] + ~where:meta_proof + in + (* + debug_print + (lazy + (Printf.sprintf "status:\n%s\n%s\n%s\n%s\n" + (match uri with Some uri -> UriManager.string_of_uri uri + | None -> "") + (print_metasenv newmetasenv) + (CicPp.pp real_proof [](* names *)) + (CicPp.pp term_to_prove names))); + *) + let open_goals = List.map (fun (i,_,_) -> i) proof_menv in + (uri, newmetasenv, real_proof, term_to_prove), open_goals in - let tall = fs_time_info.build_all in - let tdemodulate = fs_time_info.demodulate in - let tsubsumption = fs_time_info.subsumption in if Utils.time then begin + let tall = fs_time_info.build_all in + let tdemodulate = fs_time_info.demodulate in + let tsubsumption = fs_time_info.subsumption in prerr_endline ( (Printf.sprintf "\nTIME NEEDED: %.9f" time) ^ (Printf.sprintf "\ntall: %.9f" tall) ^ (Printf.sprintf "\ntdemod: %.9f" tdemodulate) ^ (Printf.sprintf "\ntsubsumption: %.9f" tsubsumption) ^ (Printf.sprintf "\ninfer_time: %.9f" !infer_time) ^ - (Printf.sprintf "\nforward_simpl_times: %.9f" !forward_simpl_time) ^ + (Printf.sprintf "\nforward_simpl_times: %.9f" + !forward_simpl_time) ^ (Printf.sprintf "\nforward_simpl_new_times: %.9f" - !forward_simpl_new_time) ^ - (Printf.sprintf "\nbackward_simpl_times: %.9f" !backward_simpl_time) ^ + !forward_simpl_new_time) ^ + (Printf.sprintf "\nbackward_simpl_times: %.9f" + !backward_simpl_time) ^ (Printf.sprintf "\npassive_maintainance_time: %.9f" !passive_maintainance_time)) end; - newstatus - | _ -> - raise (ProofEngineTypes.Fail (lazy "NO proof found")) + newstatus ;; -(* dummy function called within matita to trigger linkage *) -let init () = ();; - - let retrieve_and_print dbd term metasenv ugraph = let module C = Cic in let module T = CicTypeChecker in @@ -1831,8 +2011,7 @@ let main_demod_equalities dbd term metasenv ugraph = in let env = (metasenv, context, ugraph) in (*try*) - let goal = - ([],Equality.BasicProof (Equality.empty_subst,new_meta_goal)), [], goal + let goal = [], [], goal in let equalities = simplify_equalities env (equalities@library_equalities) in let active = make_active () in @@ -1892,10 +2071,7 @@ let demodulate_tac ~dbd ~pattern ((proof,goal) as initialstatus) = if library_equalities = [] then prerr_endline "VUOTA!!!"; let irl = CicMkImplicit.identity_relocation_list_for_metavariable context in let library_equalities = List.map snd library_equalities in - let goalterm = Cic.Meta (metano,irl) in - let initgoal = - ([],Equality.BasicProof (Equality.empty_subst,goalterm)), [], ty - in + let initgoal = [], [], ty in let env = (metasenv, context, CicUniv.empty_ugraph) in let equalities = simplify_equalities env (equalities@library_equalities) in let table = @@ -1911,7 +2087,7 @@ let demodulate_tac ~dbd ~pattern ((proof,goal) as initialstatus) = begin let opengoal = Cic.Meta(maxm,irl) in let proofterm = - Equality.build_proof_term_old ~noproof:opengoal (snd newproof) in + Equality.build_goal_proof newproof opengoal ty in let extended_metasenv = (maxm,context,newty)::metasenv in let extended_status = (curi,extended_metasenv,pbo,pty),goal in