X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fsoftware%2Fcomponents%2Ftactics%2Fparamodulation%2Fsaturation.ml;h=b71f5e5b6fbd7002191d354ab996e7b5e8f7da12;hb=013d4d79c16ee332672a64dca289979fe1e81348;hp=5b5121e8677ea61a45642b6fd236302e9e4d6540;hpb=d811085efd81ce196a2d6cfee54ce1eb7a076a22;p=helm.git diff --git a/helm/software/components/tactics/paramodulation/saturation.ml b/helm/software/components/tactics/paramodulation/saturation.ml index 5b5121e86..b71f5e5b6 100644 --- a/helm/software/components/tactics/paramodulation/saturation.ml +++ b/helm/software/components/tactics/paramodulation/saturation.ml @@ -23,6 +23,8 @@ * http://cs.unibo.it/helm/. *) +let _profiler = <:profiler<_profiler>>;; + (* $Id$ *) open Inference;; @@ -70,16 +72,19 @@ let maxmeta = ref 0;; let maxdepth = ref 3;; let maxwidth = ref 3;; +type new_proof = + Equality.goal_proof * Equality.proof * int * Subst.substitution * Cic.metasenv type result = - | ParamodulationFailure - | ParamodulationSuccess of (Inference.proof * Cic.metasenv) option + | ParamodulationFailure of string + | ParamodulationSuccess of new_proof ;; -type goal = proof * Cic.metasenv * Cic.term;; +type goal = Equality.goal_proof * Cic.metasenv * Cic.term;; type theorem = Cic.term * Cic.term * Cic.metasenv;; -let symbols_of_equality (_, _, (_, left, right, _), _) = +let symbols_of_equality equality = + let (_, _, (_, left, right, _), _,_) = Equality.open_equality equality in let m1 = symbols_of_term left in let m = TermMap.fold @@ -96,18 +101,19 @@ let symbols_of_equality (_, _, (_, left, right, _), _) = (* griggio *) module OrderedEquality = struct - type t = Inference.equality + type t = Equality.equality let compare eq1 eq2 = - match meta_convertibility_eq eq1 eq2 with + match Equality.meta_convertibility_eq eq1 eq2 with | true -> 0 - | false -> - let w1, _, (ty, left, right, _), m1 = eq1 - and w2, _, (ty', left', right', _), m2 = eq2 in + | 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 | 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 @@ -136,24 +142,34 @@ let age_factor = 0.01;; of weight, age and goal-similarity *) -let rec select env goals passive = +let rec select env (goals,_) passive = processed_clauses := !processed_clauses + 1; let goal = - match (List.rev goals) with (_, goal::_)::_ -> goal | _ -> assert false + match (List.rev goals) with goal::_ -> goal | _ -> assert false in let (pos_list, pos_set), passive_table = passive in - let remove eq l = List.filter (fun e -> e <> eq) l in + let remove eq l = List.filter (fun e -> Equality.compare e eq <> 0) l in if !weight_age_ratio > 0 then weight_age_counter := !weight_age_counter - 1; 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 = @@ -192,7 +208,7 @@ let rec select env goals passive = let passive_table = Indexing.remove_index passive_table current in - current, + current, ((remove current pos_list, EqualitySet.remove current pos_set), passive_table)) | _ -> @@ -206,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 = @@ -255,8 +293,6 @@ let prune_passive howmany (active, _) passive = and in_age = round (howmany /. (ratio +. 1.)) in debug_print (lazy (Printf.sprintf "in_weight: %d, in_age: %d\n" in_weight in_age)); - let symbols, card = None, 0 - in let counter = ref !symbols_ratio in let rec pickw w ps = if w > 0 then @@ -264,7 +300,7 @@ let prune_passive howmany (active, _) passive = let _ = counter := !counter - 1; if !counter = 0 then counter := !symbols_ratio in - let e = EqualitySet.min_elt ps in + let e = EqualitySet.min_elt ps in let ps' = pickw (w-1) (EqualitySet.remove e ps) in EqualitySet.add e ps' else @@ -300,14 +336,20 @@ let prune_passive howmany (active, _) passive = (** inference of new equalities between current and some in active *) -let infer env current ((active_list:Inference.equality list), active_table) = +let infer env current (active_list, active_table) = let (_,c,_) = env in if Utils.debug_metas then (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 -> @@ -317,7 +359,8 @@ let infer env current ((active_list:Inference.equality 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 @@ -325,18 +368,21 @@ let infer env current ((active_list:Inference.equality list), active_table) = (function current -> Indexing.check_target c current "sup2") res); let pos = infer_positive table tl in - res @ pos + res @ pos in - let maxm, copy_of_current = Inference.fix_metas !maxmeta current 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 @@ -351,6 +397,73 @@ let infer env current ((active_list:Inference.equality 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 + 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 *) @@ -365,7 +478,7 @@ let forward_simplify env (sign,current) ?passive (active_list, active_table) = let newmeta, newcurrent = Indexing.demodulation_equality !maxmeta env table sign current in maxmeta := newmeta; - if is_identity env newcurrent then + if Equality.is_identity env newcurrent then (* debug_print *) (* (lazy *) (* (Printf.sprintf "\ncurrent was: %s\nnewcurrent is: %s\n" *) @@ -396,7 +509,7 @@ let forward_simplify env (sign,current) ?passive (active_list, active_table) = match demodulate passive_table newcurrent with | None -> None | Some newnewcurrent -> - if newcurrent <> newnewcurrent then + if Equality.compare newcurrent newnewcurrent <> 0 then demod newnewcurrent else Some newnewcurrent in @@ -409,20 +522,33 @@ let forward_simplify env (sign,current) ?passive (active_list, active_table) = 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 = { @@ -443,37 +569,28 @@ 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 (Inference.is_identity env e) then - if EqualitySet.mem e s then s - else EqualitySet.add e s + if not (Equality.is_identity env e) then +(* if EqualitySet.mem e s then s *) + (*else*) EqualitySet.add e s else s) EqualitySet.empty new_pos in @@ -499,7 +616,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) ;; @@ -510,20 +627,14 @@ let rec simplify_goal env goal ?passive (active_list, active_table) = | None -> None | Some ((_, _), pt) -> Some pt in - - let demodulate table goal = - let newmeta, newgoal = - Indexing.demodulation_goal !maxmeta env table goal in - maxmeta := newmeta; - goal <> newgoal, newgoal - in + let demodulate table goal = Indexing.demodulation_goal env table goal in let changed, goal = match passive_table with | 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 @@ -537,70 +648,63 @@ let simplify_goals env goals ?passive active = let a_goals, p_goals = goals in let p_goals = List.map - (fun (d, gl) -> - let gl = - List.map (fun g -> snd (simplify_goal env g ?passive active)) gl in - d, gl) + (fun g -> snd (simplify_goal env g ?passive active)) p_goals in - let goals = - List.fold_left - (fun (a, p) (d, gl) -> - let changed = ref false in - let gl = - List.map - (fun g -> - let c, g = simplify_goal env g ?passive active in - changed := !changed || c; g) gl in - if !changed then (a, (d, gl)::p) else ((d, gl)::a, p)) - ([], p_goals) a_goals + let a_goals = + List.map + (fun g -> snd (simplify_goal env g ?passive active)) + a_goals in - goals + a_goals, p_goals ;; (** 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 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 = e then - e::res, newn + if Equality.compare equality e = 0 then + e::res, newn, pruned else - res, e::newn) - active_list ([], []) + res, e::newn, pruned) + active_list ([], [],[]) in let find eq1 where = - List.exists (meta_convertibility_eq eq1) where + List.exists (Equality.meta_convertibility_eq eq1) where + in + let id_of_eq eq = + let _, _, _, _,id = Equality.open_equality eq in id in - let active, newa = + 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 - else if (is_identity env eq) || (find eq res) then ( - res, tbl + (res, (id_of_eq eq)::pruned),tbl + else if (Equality.is_identity env eq) || (find eq res) then ( + (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 (is_identity env eq) then p - else eq::p) + if (Equality.is_identity env eq) then p + else eq::p) newa [] in match newa with - | [] -> active, None - | _ -> active, Some newa + | [] -> (active1,tbl), None, pruned + | _ -> (active1,tbl), Some newa, pruned ;; @@ -608,7 +712,7 @@ let backward_simplify_active env new_pos new_table min_weight active = let backward_simplify_passive env new_pos new_table min_weight passive = let (pl, ps), passive_table = passive in let f sign equality (resl, ress, newn) = - let ew, _, _, _ = equality in + let ew, _, _, _ , _ = Equality.open_equality equality in if ew < min_weight then equality::resl, ress, newn else @@ -631,22 +735,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, _, _, _ = e in + 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 @@ -658,7 +772,7 @@ let close env new' given = let new_pos, new_table, min_weight = List.fold_left (fun (l, t, w) e -> - let ew, _, _, _ = e in + let ew, _, _, _ , _ = Equality.open_equality e in e::l, Indexing.index t e, min ew w) ([], Indexing.empty, 1000000) (snd new') in @@ -670,7 +784,9 @@ let close env new' given = ;; let is_commutative_law eq = - let w, proof, (eq_ty, left, right, order), metas = eq in + let w, proof, (eq_ty, left, right, order), metas , _ = + Equality.open_equality eq + in match left,right with Cic.Appl[f1;Cic.Meta _ as a1;Cic.Meta _ as b1], Cic.Appl[f2;Cic.Meta _ as a2;Cic.Meta _ as b2] -> @@ -686,7 +802,7 @@ let prova env new' active = (Printf.sprintf "symmetric:\n%s\n" (String.concat "\n" (List.map - (fun e -> string_of_equality ~env e) + (fun e -> Equality.string_of_equality ~env e) given)))) in close env new' given ;; @@ -709,6 +825,9 @@ let make_goals goal = active, passive ;; +let make_goal_set goal = + ([],[goal]) +;; (** initializes the set of theorems *) let make_theorems theorems = @@ -794,7 +913,7 @@ let simplify_equalities env equalities = (lazy (Printf.sprintf "equalities:\n%s\n" (String.concat "\n" - (List.map string_of_equality equalities)))); + (List.map Equality.string_of_equality equalities)))); debug_print (lazy "SIMPLYFYING EQUALITIES..."); match equalities with | [] -> [] @@ -806,7 +925,7 @@ let simplify_equalities env equalities = (lazy (Printf.sprintf "equalities AFTER:\n%s\n" (String.concat "\n" - (List.map string_of_equality res)))); + (List.map Equality.string_of_equality res)))); res ;; @@ -822,28 +941,26 @@ let print_goals goals = Printf.sprintf "%d: %s" d (String.concat "; " gl')) goals)) ;; -let check_if_goal_is_subsumed env (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 = 0,proof,(eq_ty,left,right,Eq),menv in - match Indexing.subsumption env table goal_equation with - | Some (subst, (_,p,_,m)) -> - let p = Inference.apply_subst subst (Inference.build_proof_term p) in - let newp = - let rec repl = function - | Inference.ProofGoalBlock (_, gp) -> - Inference.ProofGoalBlock (Inference.BasicProof ([],p), gp) - | Inference.NoProof -> Inference.BasicProof ([],p) - | Inference.BasicProof _ -> Inference.BasicProof ([],p) - | Inference.SubProof (t, i, p2) -> - Inference.SubProof (t, i, repl p2) - | _ -> assert false - in - repl proof - in - Some (newp,Inference.apply_subst_metasenv subst m @ menv) - | None -> None) + (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 ) -> + 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, id, subst, cicmenv) + | None -> None) | _ -> None ;; @@ -853,11 +970,18 @@ let counter = ref 0 let rec given_clause_fullred dbd env goals theorems ~passive active = let goals = simplify_goals env goals ~passive active in let _,context,_ = env in - let ok, goals = activate_goal goals in + let ok, (goals: + (Equality.goal_proof * Cic.metasenv * Cic.term) list * + (Equality.goal_proof * Cic.metasenv * Cic.term) list) = activate_goal + + (goals: + (Equality.goal_proof * Cic.metasenv * Cic.term) list * + (Equality.goal_proof * Cic.metasenv * Cic.term) list) + in (* let theorems = simplify_theorems env theorems ~passive active in *) if ok then let names = List.map (HExtlib.map_option (fun (name,_) -> name)) context in - let _, _, t = List.hd (snd (List.hd (fst goals))) in + let _, _, t = List.hd (fst goals) in let _ = prerr_endline ("goal activated = " ^ (CicPp.pp t names)) in (* let _ = *) (* debug_print *) @@ -874,31 +998,17 @@ let rec given_clause_fullred dbd env goals theorems ~passive active = let ok, proof = (* 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]])::_ + match fst goals with + | (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 - | Inference.ProofGoalBlock (_, gp) -> - Inference.ProofGoalBlock (Inference.BasicProof ([],p), gp) - | Inference.NoProof -> Inference.BasicProof ([],p) - | Inference.BasicProof _ -> Inference.BasicProof ([],p) - | Inference.SubProof (t, i, p2) -> - Inference.SubProof (t, i, repl p2) - | _ -> assert false - in - repl proof - in true, Some (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, 0, Subst.empty_subst,m) + | goal::_ -> + (match check_if_goal_is_subsumed env (snd active) goal with | None -> false,None - | Some (newproof,m) -> + | Some p -> prerr_endline "Proof found by subsumption!"; - true, Some (newproof,m)) + true, Some p) | _ -> false, None in if ok then @@ -917,7 +1027,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 @@ -934,13 +1046,12 @@ 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 = prerr_endline (string_of_int !counter ^ " MAXMETA: " ^ string_of_int !maxmeta ^ - " LOCALMAX: " ^ string_of_int !Indexing.local_max ^ " #ACTIVES: " ^ string_of_int (size_of_active active) ^ " #PASSIVES: " ^ string_of_int (size_of_passive passive)); incr counter; @@ -1003,12 +1114,12 @@ 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 + let current, passive = select env goals passive in prerr_endline - ("Selected = " ^ string_of_equality ~env current); + ("Selected = " ^ Equality.string_of_equality ~env current); (* ^ (let w,p,(t,l,r,o),m = current in " size w: " ^ string_of_int (HExtlib.estimate_size w)^ @@ -1029,8 +1140,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 -> - debug_print (lazy (Printf.sprintf "selected: %s" - (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 _ = @@ -1040,12 +1151,12 @@ and given_clause_fullred_aux dbd env goals theorems passive active = (String.concat "\n" (List.map (fun e -> "Positive " ^ - (string_of_equality ~env e)) new')))) + (Equality.string_of_equality ~env e)) new')))) in let t2 = Unix.gettimeofday () in infer_time := !infer_time +. (t2 -. t1); let active = - if is_identity env current then active + if Equality.is_identity env current then active else let al, tbl = active in al @ [current], Indexing.index tbl current @@ -1057,26 +1168,32 @@ 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 | None, None -> active, passive, new' | Some p, None | None, Some p -> - let np = new' in - if Utils.debug_metas then - begin - List.iter - (fun x->Indexing.check_target context x "simplify1") - p; - end; - simplify (new' @ p) active passive + if Utils.debug_metas then + begin + List.iter + (fun x->Indexing.check_target context x "simplify1") + p; + end; + simplify (new' @ p) active passive | 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 @@ -1105,7 +1222,7 @@ end prova *) (Printf.sprintf "active:\n%s\n" (String.concat "\n" ((List.map - (fun e -> (string_of_equality ~env e)) + (fun e -> (Equality.string_of_equality ~env e)) (fst active)))))) in let _ = @@ -1115,7 +1232,7 @@ end prova *) (String.concat "\n" ((List.map (fun e -> "Negative " ^ - (string_of_equality ~env e)) new'))))) + (Equality.string_of_equality ~env e)) new'))))) in let passive = add_to_passive passive new' in given_clause_fullred dbd env goals theorems passive active @@ -1129,31 +1246,222 @@ 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, 0, 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 active_goals, passive_goals = goals in + let find (_,_,g) where = + List.exists (fun (_,_,g1) -> Equality.meta_convertibility g g1) where + in + let simplified = + List.fold_left + (fun acc goal -> + match simplify_goal env goal ~passive active with + | _, g -> if find g acc then acc else g::acc) + [] active_goals + in + if List.length active_goals <> List.length simplified then + prerr_endline "SEMPLIFICANDO HO SCARTATO..."; + (simplified,passive_goals) + (* + 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 = + let active_goals, passive_goals = goals in + 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 active_goals +;; + +let infer_goal_set env active goals = + let active_goals, passive_goals = goals in + let rec aux = function + | [] -> goals + | ((_,_,t1) as hd)::tl when + not (List.exists + (fun (_,_,t) -> Equality.meta_convertibility t t1) + active_goals) + -> + let selected = hd in + let passive_goals = tl in + let new' = Indexing.superposition_left env (snd active) selected in + selected::active_goals, passive_goals @ new' + | _::tl -> aux tl + in + aux passive_goals +;; + +let infer_goal_set_with_current env current goals = + let active_goals, passive_goals = goals in + let _,table,_ = build_table [current] in + active_goals, + List.fold_left + (fun acc g -> + let new' = Indexing.superposition_left env table g in + acc @ new') + passive_goals active_goals +;; + + + +let size_of_goal_set_a (l,_) = List.length l;; +let size_of_goal_set_p (_,l) = List.length l;; + +(** 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 _ = prerr_endline "simpl goal with active" in + let goals = simplify_goal_set env goals passive active in + match check_if_goals_set_is_solved env active goals with + | Some p -> + prerr_endline + (Printf.sprintf "Found a proof in: %f\n" + (Unix.gettimeofday() -. initial_time)); +(* assert false;*) + ParamodulationSuccess p + | None -> + prerr_endline + (Printf.sprintf "%d #ACTIVES: %d #PASSIVES: %d #GOALSET: %d(%d)\n" + iterno (size_of_active active) (size_of_passive passive) + (size_of_goal_set_a goals) (size_of_goal_set_p 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 goals = infer_goal_set env active goals in + let current, passive = select env goals passive in + 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 + 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 = + 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 + 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 + prerr_endline "simpl goal with new"; + 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; if !elapsed_time > !time_limit then (active, passive) else - let current, passive = select env [1, [goal]] passive in + let current, passive = select env ([goal],[]) passive in let res = forward_simplify env (Positive, current) ~passive active in match res with | None -> saturate_equations env goal accept_fun passive active | Some current -> debug_print (lazy (Printf.sprintf "selected: %s" - (string_of_equality ~env current))); + (Equality.string_of_equality ~env current))); let new' = infer env current active in let active = - if is_identity env current then active + if Equality.is_identity env current then active else let al, tbl = active in al @ [current], Indexing.index tbl current 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 @@ -1167,24 +1475,25 @@ let rec saturate_equations env goal accept_fun passive active = (Printf.sprintf "active:\n%s\n" (String.concat "\n" (List.map - (fun e -> string_of_equality ~env e) + (fun e -> Equality.string_of_equality ~env e) (fst active))))) in - let _ = + let _ = debug_print (lazy (Printf.sprintf "new':\n%s\n" (String.concat "\n" (List.map (fun e -> "Negative " ^ - (string_of_equality ~env e)) new')))) + (Equality.string_of_equality ~env e)) new')))) in let new' = List.filter accept_fun new' in let passive = add_to_passive passive new' in saturate_equations env goal accept_fun passive active ;; - +let main dbd full term metasenv ugraph = () +(* let main dbd full term metasenv ugraph = let module C = Cic in let module T = CicTypeChecker in @@ -1246,7 +1555,9 @@ let main dbd full term metasenv ugraph = (fst theorems))))) in (*try*) - let goal = Inference.BasicProof ([],new_meta_goal), [], goal in + let goal = + ([],Equality.BasicProof (Equality.empty_subst ,new_meta_goal)), [], goal + in let equalities = simplify_equalities env (equalities@library_equalities) in let active = make_active () in @@ -1258,7 +1569,7 @@ let main dbd full term metasenv ugraph = Printf.printf "\nequalities:\n%s\n" (String.concat "\n" (List.map - (string_of_equality ~env) equalities)); + (Equality.string_of_equality ~env) equalities)); (* (equalities @ library_equalities))); *) print_endline "--------------------------------------------------"; let start = Unix.gettimeofday () in @@ -1274,17 +1585,27 @@ let main dbd full term metasenv ugraph = match res with | ParamodulationFailure -> Printf.printf "NO proof found! :-(\n\n" - | ParamodulationSuccess (Some (proof, env)) -> - let proof = Inference.build_proof_term proof in + | ParamodulationSuccess (Some ((cicproof,cicmenv),(proof, env))) -> Printf.printf "OK, found a proof!\n"; + let oldproof = Equation.build_proof_term proof in + let newproof,_,newenv,_ = + CicRefine.type_of_aux' + cicmenv context cicproof CicUniv.empty_ugraph + in (* REMEMBER: we have to instantiate meta_proof, we should use apply the "apply" tactic to proof and status *) let names = names_of_context context in + prerr_endline "OLD PROOF"; print_endline (PP.pp proof names); + prerr_endline "NEW PROOF"; + print_endline (PP.pp newproof names); let newmetasenv = List.fold_left - (fun m (_, _, _, menv) -> m @ menv) metasenv equalities + (fun m eq -> + let (_, _, _, menv,_) = Equality.open_equality eq in + m @ menv) + metasenv equalities in let _ = (*try*) @@ -1316,8 +1637,6 @@ let main dbd full term metasenv ugraph = "backward_simpl_time: %.9f\n") !infer_time !forward_simpl_time !forward_simpl_new_time !backward_simpl_time) ^ - (Printf.sprintf "beta_expand_time: %.9f\n" - !Indexing.beta_expand_time) ^ (Printf.sprintf "passive_maintainance_time: %.9f\n" !passive_maintainance_time) ^ (Printf.sprintf " successful unification/matching time: %.9f\n" @@ -1337,14 +1656,13 @@ let main dbd full term metasenv ugraph = raise exc *) ;; - +*) let default_depth = !maxdepth and default_width = !maxwidth;; let reset_refs () = maxmeta := 0; - Indexing.local_max := 100; symbols_counter := 0; weight_age_counter := !weight_age_ratio; processed_clauses := 0; @@ -1358,8 +1676,7 @@ let reset_refs () = passive_maintainance_time := 0.; derived_clauses := 0; kept_clauses := 0; - Indexing.beta_expand_time := 0.; - Inference.metas_of_proof_time := 0.; + Equality.reset (); ;; let saturate @@ -1371,29 +1688,18 @@ let saturate maxdepth := depth; maxwidth := width; (* CicUnification.unif_ty := false;*) - let proof, goal = status in - let goal' = goal in + let proof, goalno = status in let uri, metasenv, meta_proof, term_to_prove = proof in - let _, context, goal = CicUtil.lookup_meta goal' metasenv in - prerr_endline ("CTX: " ^ string_of_int (HExtlib.estimate_size context)); + let _, context, type_of_goal = CicUtil.lookup_meta goalno 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 = - CicMkImplicit.identity_relocation_list_for_metavariable context in - let _, context, ty = CicUtil.lookup_meta goal' metasenv in - debug_print - (lazy (Printf.sprintf "\n\nTIPO DEL GOAL: %s\n" (CicPp.ppterm ty))); - Cic.Meta (maxm+1, irl), - (maxm+1, context, ty)::metasenv, - ty - in let ugraph = CicUniv.empty_ugraph in let env = (metasenv, context, ugraph) in - let goal = Inference.BasicProof ([],new_meta_goal), [], 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 = - find_library_equalities dbd context (proof, goal') (maxm+2) + find_library_equalities dbd context (proof, goalno) (maxm+2) in let library_equalities = List.map snd library_equalities in let t2 = Unix.gettimeofday () in @@ -1405,7 +1711,7 @@ let saturate let t1 = Unix.gettimeofday () in let theorems = if full then - let thms = find_library_theorems dbd env (proof, goal') lib_eq_uris in + let thms = find_library_theorems dbd env (proof, goalno) lib_eq_uris in let context_hyp = find_context_hypotheses env eq_indexes in context_hyp @ thms, [] else @@ -1438,117 +1744,131 @@ 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 = make_goal_set goal in + let max_iterations = 1000 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 (res, finish -. start) in match res with - | ParamodulationSuccess (Some (proof, proof_menv)) -> + | ParamodulationFailure s -> + raise (ProofEngineTypes.Fail (lazy ("NO proof found: " ^ s))) + | ParamodulationSuccess + (goalproof,newproof,subsumption_id,subsumption_subst, proof_menv) -> prerr_endline "OK, found a proof!"; - debug_print (lazy "OK, found a proof!"); - let proof = Inference.build_proof_term proof in - let equality_for_replace i t1 = - match t1 with - | C.Meta (n, _) -> n = i - | _ -> false + 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 = + List.filter (fun i -> i <> goalno) + (ProofEngineHelpers.compare_metasenvs + ~newmetasenv:metasenv ~oldmetasenv:proof_menv) in - prerr_endline "replacing metas"; - let proof_menv, what, with_what = - let irl = - CicMkImplicit.identity_relocation_list_for_metavariable context - in + let goal_proof, side_effects_t = + let initial = newproof in + Equality.build_goal_proof goalproof initial type_of_goal side_effects + 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 + (* replacing fake mets with real ones *) + prerr_endline "replacing metas..."; + let irl=CicMkImplicit.identity_relocation_list_for_metavariable context in + let goal_proof_menv, what, with_what,free_meta = List.fold_left - (fun (acc1,acc2,acc3) (i,_,ty) -> - (i,context,ty)::acc1, - (Cic.Meta(i,[]))::acc2, - (Cic.Meta(i,irl)) ::acc3) - ([],[],[]) proof_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 replace where = + (* we need this fake equality since the metas of the hypothesis may be + * with a real local context *) + ProofEngineReduction.replace_lifting + ~equality:(fun x y -> + match x,y with Cic.Meta(i,_),Cic.Meta(j,_) -> i=j | _-> false) + ~what ~with_what ~where in - let proof = ProofEngineReduction.replace_lifting - ~equality:(=) - ~what ~with_what - ~where:proof + 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 (CicPp.ppterm proof); *) - let names = names_of_context context in - let newmetasenv = - let i1 = - match new_meta_goal with - | C.Meta (i, _) -> i | _ -> assert false +prerr_endline ("freemetas: " ^ String.concat "," (List.map string_of_int free_metas) ); + (* check/refine/... build the new proof *) + let replaced_goal = + ProofEngineReduction.replace + ~what:side_effects ~with_what:side_effects_t + ~equality:(fun i t -> match t with Cic.Meta(j,_)->j=i|_->false) + ~where:type_of_goal + in + let subst_side_effects,real_menv,_ = + let fail t s = raise (ProofEngineTypes.Fail (lazy (t^Lazy.force s))) in + let free_metas_menv = + List.map (fun i -> CicUtil.lookup_meta i goal_proof_menv) free_metas in - List.filter (fun (i, _, _) -> i <> i1 && i <> goal') metasenv + try + CicUnification.fo_unif_subst [] context (metasenv @ free_metas_menv) + replaced_goal type_of_goal CicUniv.empty_ugraph + with + | CicUnification.UnificationFailure s + | CicUnification.Uncertain s + | CicUnification.AssertFailure s -> + fail "Maybe the local context of metas in the goal was not an IRL" s + in + let final_subst = + (goalno,(context,goal_proof,type_of_goal))::subst_side_effects in - let newmetasenv = newmetasenv@proof_menv in - let newstatus = +prerr_endline ("MENVreal_menv: " ^ CicMetaSubst.ppmetasenv [] real_menv); + let _ = try - let ty, ug = - prerr_endline "type checking ... "; - CicTypeChecker.type_of_aux' newmetasenv context proof ugraph - in - prerr_endline (CicPp.pp proof [](* names *)); - 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:[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))); - ((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 proof names)); - raise (ProofEngineTypes.Fail - (lazy "Found a proof, but it doesn't typecheck")) + CicTypeChecker.type_of_aux' real_menv context goal_proof + CicUniv.empty_ugraph + 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 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 - 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 "\nbeta_expand_time: %.9f\n" - !Indexing.beta_expand_time) ^ - (Printf.sprintf "\nmetas_of_proof: %.9f\n" - !Inference.metas_of_proof_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) ^ - (Printf.sprintf "\npassive_maintainance_time: %.9f" - !passive_maintainance_time)) - end; - newstatus - | _ -> - raise (ProofEngineTypes.Fail (lazy "NO proof found")) + 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,_)) when m<>goalno ->[m] | _ ->[] + in + Printf.eprintf + "GOALS APERTI: %s\nMETASENV PRIMA:\n%s\nMETASENV DOPO:\n%s\n" + (String.concat ", " (List.map string_of_int open_goals)) + (CicMetaSubst.ppmetasenv [] metasenv) + (CicMetaSubst.ppmetasenv [] real_metasenv); + prerr_endline (Printf.sprintf "\nTIME NEEDED: %8.2f" time); + proof, open_goals ;; -(* 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 @@ -1559,18 +1879,8 @@ let retrieve_and_print dbd term metasenv ugraph = let proof, goals = status in let goal' = List.nth goals 0 in let uri, metasenv, meta_proof, term_to_prove = proof in - let _, context, goal = CicUtil.lookup_meta goal' metasenv in + let _, context, type_of_goal = CicUtil.lookup_meta goal' metasenv in let eq_indexes, equalities, maxm = find_equalities context proof in - let new_meta_goal, metasenv, type_of_goal = - let irl = - CicMkImplicit.identity_relocation_list_for_metavariable context in - let _, context, ty = CicUtil.lookup_meta goal' metasenv in - debug_print - (lazy (Printf.sprintf "\n\nTIPO DEL GOAL: %s\n" (CicPp.ppterm ty))); - Cic.Meta (maxm+1, irl), - (maxm+1, context, ty)::metasenv, - ty - in let ugraph = CicUniv.empty_ugraph in let env = (metasenv, context, ugraph) in let t1 = Unix.gettimeofday () in @@ -1629,7 +1939,7 @@ let retrieve_and_print dbd term metasenv ugraph = (fun (u, e) -> Printf.sprintf "%s: %s" (UriManager.string_of_uri u) - (string_of_equality e) + (Equality.string_of_equality e) ) res)))); res in @@ -1669,7 +1979,8 @@ let main_demod_equalities dbd term metasenv ugraph = in let env = (metasenv, context, ugraph) in (*try*) - let goal = Inference.BasicProof ([],new_meta_goal), [], goal in + let goal = [], [], goal + in let equalities = simplify_equalities env (equalities@library_equalities) in let active = make_active () in let passive = make_passive equalities in @@ -1678,7 +1989,7 @@ let main_demod_equalities dbd term metasenv ugraph = Printf.printf "\nequalities:\n%s\n" (String.concat "\n" (List.map - (string_of_equality ~env) equalities)); + (Equality.string_of_equality ~env) equalities)); print_endline "--------------------------------------------------"; print_endline "GO!"; start_time := Unix.gettimeofday (); @@ -1705,12 +2016,12 @@ let main_demod_equalities dbd term metasenv ugraph = EqualitySet.elements (List.fold_left addfun EqualitySet.empty l) in Printf.printf "\n\nRESULTS:\nActive:\n%s\n\nPassive:\n%s\n" - (String.concat "\n" (List.map (string_of_equality ~env) active)) + (String.concat "\n" (List.map (Equality.string_of_equality ~env) active)) (* (String.concat "\n" (List.map (fun e -> CicPp.ppterm (term_of_equality e)) active)) *) (* (String.concat "\n" (List.map (string_of_equality ~env) passive)); *) (String.concat "\n" - (List.map (fun e -> CicPp.ppterm (term_of_equality e)) passive)); + (List.map (fun e -> CicPp.ppterm (Equality.term_of_equality e)) passive)); print_newline (); (* with e -> @@ -1718,7 +2029,7 @@ let main_demod_equalities dbd term metasenv ugraph = *) ;; -let demodulate_tac ~dbd ~pattern ((proof,goal) as initialstatus) = +let demodulate_tac ~dbd ~pattern ((proof,goal)(*s initialstatus*)) = let module I = Inference in let curi,metasenv,pbo,pty = proof in let metano,context,ty = CicUtil.lookup_meta goal metasenv in @@ -1728,8 +2039,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 = Inference.BasicProof ([],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 = @@ -1737,14 +2047,15 @@ let demodulate_tac ~dbd ~pattern ((proof,goal) as initialstatus) = (fun tbl eq -> Indexing.index tbl eq) Indexing.empty equalities in - let newmeta,(newproof,newmetasenv, newty) = Indexing.demodulation_goal - maxm (metasenv,context,CicUniv.empty_ugraph) table initgoal + let changed,(newproof,newmetasenv, newty) = + Indexing.demodulation_goal + (metasenv,context,CicUniv.empty_ugraph) table initgoal in - if newmeta != maxm then + if changed then begin - let opengoal = Cic.Meta(maxm,irl) in - let proofterm = - Inference.build_proof_term ~noproof:opengoal newproof 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 let extended_status = (curi,extended_metasenv,pbo,pty),goal in @@ -1754,13 +2065,17 @@ let demodulate_tac ~dbd ~pattern ((proof,goal) as initialstatus) = extended_status in (status,maxm::newgoals) end - else if newty = ty then + else (* if newty = ty then *) raise (ProofEngineTypes.Fail (lazy "no progress")) - else ProofEngineTypes.apply_tactic + (*else ProofEngineTypes.apply_tactic (ReductionTactics.simpl_tac ~pattern) - initialstatus + initialstatus*) ;; let demodulate_tac ~dbd ~pattern = ProofEngineTypes.mk_tactic (demodulate_tac ~dbd ~pattern) ;; + +let get_stats () = + <:show> ^ Indexing.get_stats () ^ Inference.get_stats ();; +