X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fsoftware%2Fcomponents%2Ftactics%2Fparamodulation%2Fsaturation.ml;h=c5f3132e9aa5e5e1cb56849862f78e09175f0aed;hb=e78cf74f8976cf0ca554f64baa9979d0423ee927;hp=cbf15f0dfdad34e6e26a8f2ba4e532c713812f79;hpb=a004949b379723275993bbbda15b004908572871;p=helm.git diff --git a/helm/software/components/tactics/paramodulation/saturation.ml b/helm/software/components/tactics/paramodulation/saturation.ml index cbf15f0df..c5f3132e9 100644 --- a/helm/software/components/tactics/paramodulation/saturation.ml +++ b/helm/software/components/tactics/paramodulation/saturation.ml @@ -23,16 +23,18 @@ * http://cs.unibo.it/helm/. *) -let _profiler = <:profiler<_profiler>>;; +(* let _profiler = <:profiler<_profiler>>;; *) (* $Id$ *) -open Inference;; -open Utils;; - (* set to false to disable paramodulation inside auto_tac *) + +let fst3 a,_,_ = a;; +let last _,_,a = a;; + let connect_to_auto = true;; +let debug_print = Utils.debug_print;; (* profiling statistics... *) let infer_time = ref 0.;; @@ -65,36 +67,24 @@ let symbols_counter = ref 0;; let derived_clauses = ref 0;; let kept_clauses = ref 0;; -(* index of the greatest Cic.Meta created - TODO: find a better way! *) -let maxmeta = ref 0;; - (* varbiables controlling the search-space *) let maxdepth = ref 3;; let maxwidth = ref 3;; -type new_proof = - Equality.goal_proof * Equality.proof * int * Subst.substitution * Cic.metasenv -type result = - | ParamodulationFailure of string - | ParamodulationSuccess of new_proof -;; - -type goal = Equality.goal_proof * Cic.metasenv * Cic.term;; - type theorem = Cic.term * Cic.term * Cic.metasenv;; let symbols_of_equality equality = let (_, _, (_, left, right, _), _,_) = Equality.open_equality equality in - let m1 = symbols_of_term left in + let m1 = Utils.symbols_of_term left in let m = - TermMap.fold + Utils.TermMap.fold (fun k v res -> try - let c = TermMap.find k res in - TermMap.add k (c+v) res + let c = Utils.TermMap.find k res in + Utils.TermMap.add k (c+v) res with Not_found -> - TermMap.add k v res) - (symbols_of_term right) m1 + Utils.TermMap.add k v res) + (Utils.symbols_of_term right) m1 in m ;; @@ -119,26 +109,49 @@ end module EqualitySet = Set.Make(OrderedEquality);; -exception Empty_list;; - -let passive_is_empty = function - | ([], _), _ -> true - | _ -> false +type passive_table = Equality.equality list * EqualitySet.t * Indexing.Index.t +type active_table = Equality.equality list * Indexing.Index.t +type new_proof = + Equality.goal_proof * Equality.proof * int * Subst.substitution * Cic.metasenv +type result = + | ParamodulationFailure of + string * active_table * passive_table * Equality.equality_bag + | ParamodulationSuccess of + new_proof * active_table * passive_table * Equality.equality_bag ;; -let no_more_passive_goals = function - | _,[] -> true - | _ -> false +let list_of_passive (l,_,_) = l ;; +let list_of_active (l,_) = l ;; + +let make_passive eq_list = + let set = + List.fold_left (fun s e -> EqualitySet.add e s) EqualitySet.empty eq_list + in + (* we have the invariant that the list and the set have the same + * cardinality *) + EqualitySet.elements set, set, + List.fold_left Indexing.index Indexing.empty eq_list ;; - -let size_of_passive ((passive_list, ps), _) = List.length passive_list -(* EqualitySet.cardinal ps *) + +let make_empty_active () = [], Indexing.empty ;; +let make_active eq_list = + eq_list, List.fold_left Indexing.index Indexing.empty eq_list ;; +let size_of_passive (passive_list, _,_) = List.length passive_list;; +let size_of_active (active_list, _) = List.length active_list;; -let size_of_active (active_list, _) = List.length active_list +let passive_is_empty = function + | [], s , _ when EqualitySet.is_empty s -> true + | [], s ,_ -> assert false (* the set and the list should be in sync *) + | _ -> false ;; +type goals = Equality.goal list * Equality.goal list + +let no_more_passive_goals g = match g with | _,[] -> true | _ -> false;; + + let age_factor = 0.01;; (** @@ -146,47 +159,68 @@ let age_factor = 0.01;; of weight, age and goal-similarity *) -let rec select env (goals,_) passive = +let rec select env g passive = processed_clauses := !processed_clauses + 1; +(* let goal = match (List.rev goals) with goal::_ -> goal | _ -> assert false in - let (pos_list, pos_set), passive_table = passive in +*) + let pos_list, pos_set, pos_table = passive 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; - let rec skip_giant pos_list pos_set passive_table = + let skip_giant pos_list pos_set pos_table = + match pos_list with + | (hd:EqualitySet.elt)::tl -> + let w,_,_,_,_ = Equality.open_equality hd in + if w < 30 then + hd, (tl, EqualitySet.remove hd pos_set, + Indexing.remove_index pos_table hd) + else +(* + (prerr_endline + ("+++ skipping giant of size "^string_of_int w^" +++"); +*) + select env g (tl@[hd],pos_set,pos_table) + | _ -> assert false + in + skip_giant pos_list pos_set pos_table) + +(* + let rec skip_giant pos_list pos_set = 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) + if w < 30 then + hd, (tl, pos_set) else - (prerr_endline ("\n\n\nGIANT SKIPPED: "^string_of_int w^"\n\n\n"); - skip_giant tl pos_set passive_table) + (prerr_endline + ("+++ skipping giant of size "^string_of_int w^" +++"); + skip_giant tl pos_set) | _ -> assert false - in - skip_giant pos_list pos_set passive_table) + in + skip_giant pos_list pos_set) + +*) +(* | _ when (!symbols_counter > 0) -> (symbols_counter := !symbols_counter - 1; let cardinality map = - TermMap.fold (fun k v res -> res + v) map 0 + Utils.TermMap.fold (fun k v res -> res + v) map 0 in let symbols = let _, _, term = goal in - symbols_of_term term + Utils.symbols_of_term term in let card = cardinality symbols in let foldfun k v (r1, r2) = - if TermMap.mem k symbols then - let c = TermMap.find k symbols in + if Utils.TermMap.mem k symbols then + let c = Utils.TermMap.find k symbols in let c1 = abs (c - v) in let c2 = v - c1 in r1 + c2, r2 + c1 @@ -195,7 +229,7 @@ let rec select env (goals,_) passive = in let f equality (i, e) = let common, others = - TermMap.fold foldfun (symbols_of_equality equality) (0, 0) + Utils.TermMap.fold foldfun (symbols_of_equality equality) (0, 0) in let c = others + (abs (common - card)) in if c < i then (c, equality) @@ -204,92 +238,67 @@ let rec select env (goals,_) passive = let e1 = EqualitySet.min_elt pos_set in let initial = let common, others = - TermMap.fold foldfun (symbols_of_equality e1) (0, 0) + Utils.TermMap.fold foldfun (symbols_of_equality e1) (0, 0) in (others + (abs (common - card))), e1 in let _, current = EqualitySet.fold f pos_set initial in - let passive_table = - Indexing.remove_index passive_table current - in current, - ((remove current pos_list, EqualitySet.remove current pos_set), - passive_table)) + (remove current pos_list, EqualitySet.remove current pos_set)) +*) | _ -> symbols_counter := !symbols_ratio; let my_min e1 e2 = let w1,_,_,_,_ = Equality.open_equality e1 in - let w2,_,_,_,_ = Equality.open_equality e2 in - if w1 < w2 then e1 else e2 + let w2,_,_,_,_ = Equality.open_equality e2 in + if w1 < w2 then e1 else e2 in let rec my_min_elt min = function | [] -> min - | hd::tl -> my_min_elt (my_min hd min) tl + | hd::tl -> my_min_elt (my_min hd min) tl in - (* let current = EqualitySet.min_elt pos_set in *) - let current = my_min_elt (List.hd pos_list) (List.tl pos_list) in - let passive_table = - Indexing.remove_index passive_table current - in - current, - ((remove current pos_list, EqualitySet.remove current pos_set), - passive_table) +(* let current = EqualitySet.min_elt pos_set in *) + let current = my_min_elt (List.hd pos_list) (List.tl pos_list) in + current,(remove current pos_list, EqualitySet.remove current pos_set, + Indexing.remove_index pos_table current) ;; -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 = + +let filter_dependent bag passive id = + let pos_list, pos_set, pos_table = passive in + let passive,no_pruned = 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)) + (fun eq ((list,set,table),no) -> + if Equality.depend bag eq id then + (list, EqualitySet.remove eq set,Indexing.remove_index table eq), + no + 1 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 = - let set_of equalities = - List.fold_left (fun s e -> EqualitySet.add e s) EqualitySet.empty equalities + (eq::list,set,table), no) + pos_list (([],pos_set,pos_table),0) in - let table = - List.fold_left (fun tbl e -> Indexing.index tbl e) Indexing.empty pos - in - (pos, set_of pos), - table -;; - - -let make_active () = - [], Indexing.empty +(* + if no_pruned > 0 then + prerr_endline ("+++ pruning "^ string_of_int no_pruned ^" passives +++"); +*) + passive ;; (* adds to passive a list of equalities new_pos *) -let add_to_passive passive new_pos = - let (pos_list, pos_set), table = passive in +let add_to_passive passive new_pos preferred = + let pos_list, pos_set , pos_table = passive in let ok set equality = not (EqualitySet.mem equality set) in let pos = List.filter (ok pos_set) new_pos in - let table = - List.fold_left (fun tbl e -> Indexing.index tbl e) table pos - in let add set equalities = List.fold_left (fun s e -> EqualitySet.add e s) set equalities in - (pos_list @ pos, add pos_set pos), - table + let pos_head, pos_tail = + List.partition + (fun e -> List.exists (fun x -> Equality.compare x e = 0) preferred) + pos + in + pos_head @ pos_list @ pos_tail, add pos_set pos, + List.fold_left Indexing.index pos_table pos ;; (* TODO *) @@ -305,7 +314,7 @@ let prune_passive howmany (active, _) passive = in let in_weight = round (howmany *. ratio /. (ratio +. 1.)) and in_age = round (howmany /. (ratio +. 1.)) in - debug_print + Utils.debug_print (lazy (Printf.sprintf "in_weight: %d, in_age: %d\n" in_weight in_age)); let counter = ref !symbols_ratio in let rec pickw w ps = @@ -350,58 +359,49 @@ let prune_passive howmany (active, _) passive = (** inference of new equalities between current and some in active *) -let infer eq_uri env current (active_list, active_table) = +let infer bag eq_uri 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, copy_of_current = Equality.fix_metas !maxmeta current in - maxmeta := maxm; + (ignore(Indexing.check_target bag c current "infer1"); + ignore(List.map (function current -> Indexing.check_target bag c current "infer2") active_list)); + let bag, new_pos = + let bag, copy_of_current = Equality.fix_metas bag current in let active_table = Indexing.index active_table copy_of_current in - let _ = <:start> in - let maxm, res = - Indexing.superposition_right eq_uri !maxmeta env active_table current +(* let _ = <:start> in *) + let bag, res = + Indexing.superposition_right bag eq_uri env active_table current in - let _ = <:stop> in +(* let _ = <:stop> in *) if Utils.debug_metas then ignore(List.map (function current -> - Indexing.check_target c current "sup0") res); - maxmeta := maxm; - let rec infer_positive table = function - | [] -> [] + Indexing.check_target bag c current "sup0") res); + let rec infer_positive bag table = function + | [] -> bag, [] | equality::tl -> - let maxm, res = - Indexing.superposition_right - ~subterms_only:true eq_uri !maxmeta env table equality + let bag, res = + Indexing.superposition_right bag + ~subterms_only:true eq_uri env table equality in - maxmeta := maxm; if Utils.debug_metas then ignore (List.map (function current -> - Indexing.check_target c current "sup2") res); - let pos = infer_positive table tl in - res @ pos + Indexing.check_target bag c current "sup2") res); + let bag, pos = infer_positive bag table tl in + bag, 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 _ = <:start> in - let pos = infer_positive curr_table ((*copy_of_current::*)active_list) in - let _ = <:stop> in + let bag, pos = infer_positive bag curr_table ((*copy_of_current::*)active_list) in if Utils.debug_metas then ignore(List.map (function current -> - Indexing.check_target c current "sup3") pos); - res @ pos + Indexing.check_target bag c current "sup3") pos); + bag, res @ pos in derived_clauses := !derived_clauses + (List.length new_pos); match !maximal_retained_equality with - | None -> new_pos + | None -> bag, new_pos | Some eq -> ignore(assert false); (* if we have a maximal_retained_equality, we can discard all equalities @@ -409,7 +409,7 @@ let infer eq_uri env current (active_list, active_table) = greater than maximal_retained_equality if it is bigger wrt. OrderedEquality.compare and it is less similar than maximal_retained_equality to the current goal *) - List.filter (fun e -> OrderedEquality.compare e eq <= 0) new_pos + bag, List.filter (fun e -> OrderedEquality.compare e eq <= 0) new_pos ;; let check_for_deep_subsumption env active_table eq = @@ -443,110 +443,58 @@ let check_for_deep_subsumption env active_table eq = fst (aux false (true,false) left right) ;; -(* buttare via sign *) - (** simplifies current using active and passive *) -let forward_simplify - eq_uri env (sign,current) ?passive (active_list, active_table) -= +let forward_simplify bag eq_uri env current (active_list, active_table) = let _, context, _ = env in - let passive_table = - match passive with - | None -> None - | Some ((_, _), pt) -> Some pt - in - let demodulate table current = - let newmeta, newcurrent = - Indexing.demodulation_equality eq_uri !maxmeta env table sign current in - maxmeta := newmeta; - if Equality.is_identity env newcurrent then - None - else - Some newcurrent + let demodulate bag table current = + let bag, newcurrent = + Indexing.demodulation_equality bag eq_uri env table current + in + bag, if Equality.is_identity env newcurrent then None else Some newcurrent in - let rec demod current = + let demod bag current = if Utils.debug_metas then - ignore (Indexing.check_target context current "demod0"); - let res = demodulate active_table current in - if Utils.debug_metas then - ignore ((function None -> () | Some x -> - ignore (Indexing.check_target context x "demod1");()) res); - match res with - | None -> None - | Some newcurrent -> - match passive_table with - | None -> res - | Some passive_table -> - match demodulate passive_table newcurrent with - | None -> None - | Some newnewcurrent -> - if Equality.compare newcurrent newnewcurrent <> 0 then - demod newnewcurrent - else Some newnewcurrent + ignore (Indexing.check_target bag context current "demod0"); + let bag, res = demodulate bag active_table current in + if Utils.debug_metas then + ignore ((function None -> () | Some x -> + ignore (Indexing.check_target bag context x "demod1");()) res); + bag, res in - let res = demod current in + let bag, res = demod bag current in match res with - | None -> None + | None -> bag, None | Some c -> - 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 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 -*) + if Indexing.in_index active_table c || + check_for_deep_subsumption env active_table c + then + bag, None + else + bag, res ;; (** simplifies new using active and passive *) -let forward_simplify_new eq_uri env new_pos ?passive active = +let forward_simplify_new bag eq_uri env new_pos active = if Utils.debug_metas then begin let m,c,u = env in ignore(List.map - (fun current -> Indexing.check_target c current "forward new pos") + (fun current -> Indexing.check_target bag c current "forward new pos") new_pos;) end; let active_list, active_table = active in - let passive_table = - match passive with - | None -> None - | Some ((_, _), pt) -> Some pt - in - let demodulate sign table target = - let newmeta, newtarget = - Indexing.demodulation_equality eq_uri !maxmeta env table sign target + let demodulate bag table target = + let bag, newtarget = + Indexing.demodulation_equality bag eq_uri env table target in - maxmeta := newmeta; - newtarget + bag, newtarget in (* we could also demodulate using passive. Currently we don't *) - let new_pos = - List.map (demodulate Positive active_table) new_pos + let bag, new_pos = + List.fold_right (fun x (bag,acc) -> + let bag, y = demodulate bag active_table x in + bag, y::acc) + new_pos (bag,[]) in let new_pos_set = List.fold_left @@ -557,89 +505,54 @@ let forward_simplify_new eq_uri env new_pos ?passive active = EqualitySet.empty new_pos in let new_pos = EqualitySet.elements new_pos_set in - - let subs = - match passive_table with - | None -> - (fun e -> (Indexing.subsumption env active_table e = None)) - | Some passive_table -> - (fun e -> ((Indexing.subsumption env active_table e = None) && - (Indexing.subsumption env passive_table e = None))) - in - let is_duplicate = - match passive_table with - | None -> - (fun e -> not (Indexing.in_index active_table e)) - | Some passive_table -> - (fun e -> - not ((Indexing.in_index active_table e) || - (Indexing.in_index passive_table e))) - in - List.filter subs (List.filter is_duplicate new_pos) + let subs e = Indexing.subsumption env active_table e = None in + let is_duplicate e = not (Indexing.in_index active_table e) in + bag, List.filter subs (List.filter is_duplicate new_pos) ;; (** simplifies a goal with equalities in active and passive *) -let rec simplify_goal env goal ?passive (active_list, active_table) = - let passive_table = - match passive with - | None -> None - | Some ((_, _), pt) -> Some pt - 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 - in +let rec simplify_goal bag env goal (active_list, active_table) = + let demodulate table goal = Indexing.demodulation_goal bag env table goal in + let changed, goal = demodulate active_table goal in changed, if not changed then goal else - snd (simplify_goal env goal ?passive (active_list, active_table)) + snd (simplify_goal bag env goal (active_list, active_table)) ;; -let simplify_goals env goals ?passive active = +let simplify_goals bag env goals active = let a_goals, p_goals = goals in - let p_goals = - List.map - (fun g -> snd (simplify_goal env g ?passive active)) - p_goals - in - let a_goals = - List.map - (fun g -> snd (simplify_goal env g ?passive active)) - a_goals - in + let p_goals = List.map (fun g -> snd (simplify_goal bag env g active)) p_goals in + let a_goals = List.map (fun g -> snd (simplify_goal bag env g active)) a_goals in a_goals, p_goals ;; (** simplifies active usign new *) -let backward_simplify_active eq_uri env new_pos new_table min_weight active = +let backward_simplify_active + bag eq_uri env new_pos new_table min_weight active += let active_list, active_table = active in - let active_list, newa, pruned = + let bag, active_list, newa, pruned = List.fold_right - (fun equality (res, newn,pruned) -> + (fun equality (bag, res, newn,pruned) -> let ew, _, _, _,id = Equality.open_equality equality in if ew < min_weight then - equality::res, newn,pruned + bag, equality::res, newn,pruned else match - forward_simplify - eq_uri env (Utils.Positive, equality) (new_pos, new_table) + forward_simplify bag eq_uri env equality (new_pos, new_table) with - | None -> res, newn, id::pruned - | Some e -> + | bag, None -> bag, res, newn, id::pruned + | bag, Some e -> if Equality.compare equality e = 0 then - e::res, newn, pruned + bag, e::res, newn, pruned else - res, e::newn, pruned) - active_list ([], [],[]) + bag, res, e::newn, pruned) + active_list (bag, [], [],[]) in let find eq1 where = List.exists (Equality.meta_convertibility_eq eq1) where @@ -665,38 +578,42 @@ let backward_simplify_active eq_uri env new_pos new_table min_weight active = newa [] in match newa with - | [] -> (active1,tbl), None, pruned - | _ -> (active1,tbl), Some newa, pruned + | [] -> bag, (active1,tbl), None, pruned + | _ -> bag, (active1,tbl), Some newa, pruned ;; (** simplifies passive using new *) -let backward_simplify_passive eq_uri env new_pos new_table min_weight passive = +let backward_simplify_passive + bag eq_uri env new_pos new_table min_weight passive += let (pl, ps), passive_table = passive in - let f sign equality (resl, ress, newn) = + let f bag equality (resl, ress, newn) = let ew, _, _, _ , _ = Equality.open_equality equality in if ew < min_weight then - equality::resl, ress, newn + bag, (equality::resl, ress, newn) else match - forward_simplify eq_uri env (sign, equality) (new_pos, new_table) + forward_simplify bag eq_uri env equality (new_pos, new_table) with - | None -> resl, EqualitySet.remove equality ress, newn - | Some e -> + | bag, None -> + bag, (resl, EqualitySet.remove equality ress, newn) + | bag, Some e -> if equality = e then - equality::resl, ress, newn + bag, (equality::resl, ress, newn) else let ress = EqualitySet.remove equality ress in - resl, ress, e::newn + bag, (resl, ress, e::newn) in - let pl, ps, newp = List.fold_right (f Positive) pl ([], ps, []) in + let bag, (pl, ps, newp) = + List.fold_right (fun x (bag,acc) -> f bag x acc) pl (bag,([], ps, [])) in let passive_table = List.fold_left (fun tbl e -> Indexing.index tbl e) Indexing.empty pl in match newp with - | [] -> ((pl, ps), passive_table), None - | _ -> ((pl, ps), passive_table), Some (newp) + | [] -> bag, ((pl, ps), passive_table), None + | _ -> bag, ((pl, ps), passive_table), Some (newp) ;; let build_table equations = @@ -708,31 +625,15 @@ let build_table equations = ;; -let backward_simplify eq_uri env new' ?passive active = +let backward_simplify bag eq_uri env new' active = 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, pruned = - backward_simplify_active eq_uri env new_pos new_table min_weight active + let bag, active, newa, pruned = + backward_simplify_active bag eq_uri env new_pos new_table min_weight active in - match passive with - | None -> - active, (make_passive []), newa, None, pruned - | Some passive -> - active, passive, newa, None, pruned -(* prova - let passive, newp = - backward_simplify_passive env new_pos new_table min_weight passive in - active, passive, newa, newp *) + bag, active, newa, pruned ;; -let close eq_uri env new' given = +let close bag eq_uri env new' given = let new_pos, new_table, min_weight = List.fold_left (fun (l, t, w) e -> @@ -741,10 +642,10 @@ let close eq_uri env new' given = ([], Indexing.empty, 1000000) (snd new') in List.fold_left - (fun p c -> - let pos = infer eq_uri env c (new_pos,new_table) in - pos@p) - [] given + (fun (bag,p) c -> + let bag, pos = infer bag eq_uri env c (new_pos,new_table) in + bag, pos@p) + (bag,[]) given ;; let is_commutative_law eq = @@ -758,17 +659,17 @@ let is_commutative_law eq = | _ -> false ;; -let prova eq_uri env new' active = +let prova bag eq_uri env new' active = let given = List.filter is_commutative_law (fst active) in let _ = - debug_print + Utils.debug_print (lazy (Printf.sprintf "symmetric:\n%s\n" (String.concat "\n" (List.map (fun e -> Equality.string_of_equality ~env e) given)))) in - close eq_uri env new' given + close bag eq_uri env new' given ;; (* returns an estimation of how many equalities in passive can be activated @@ -815,82 +716,48 @@ let activate_theorem (active, passive) = | [] -> false, (active, passive) ;; - - -let simplify_theorems env theorems ?passive (active_list, active_table) = - let pl, passive_table = - match passive with - | None -> [], None - | Some ((pn, _), (pp, _), pt) -> - let pn = List.map (fun e -> (Negative, e)) pn - and pp = List.map (fun e -> (Positive, e)) pp in - pn @ pp, Some pt - in - let a_theorems, p_theorems = theorems in - let demodulate table theorem = - let newmeta, newthm = - Indexing.demodulation_theorem !maxmeta env table theorem in - maxmeta := newmeta; - theorem != newthm, newthm - in - let foldfun table (a, p) theorem = - let changed, theorem = demodulate table theorem in - if changed then (a, theorem::p) else (theorem::a, p) - in - let mapfun table theorem = snd (demodulate table theorem) in - match passive_table with - | None -> - let p_theorems = List.map (mapfun active_table) p_theorems in - List.fold_left (foldfun active_table) ([], p_theorems) a_theorems - | Some passive_table -> - let p_theorems = List.map (mapfun active_table) p_theorems in - let p_theorems, a_theorems = - List.fold_left (foldfun active_table) ([], p_theorems) a_theorems in - let p_theorems = List.map (mapfun passive_table) p_theorems in - List.fold_left (foldfun passive_table) ([], p_theorems) a_theorems -;; - - -let rec simpl eq_uri env e others others_simpl = +let rec simpl bag eq_uri env e others others_simpl = let active = others @ others_simpl in let tbl = List.fold_left - (fun t e -> Indexing.index t e) + (fun t e -> + if Equality.is_identity env e then t else Indexing.index t e) Indexing.empty active in - let res = forward_simplify eq_uri env (Positive,e) (active, tbl) in + let bag, res = + forward_simplify bag eq_uri env e (active, tbl) + in match others with | hd::tl -> ( match res with - | None -> simpl eq_uri env hd tl others_simpl - | Some e -> simpl eq_uri env hd tl (e::others_simpl) + | None -> simpl bag eq_uri env hd tl others_simpl + | Some e -> simpl bag eq_uri env hd tl (e::others_simpl) ) | [] -> ( match res with - | None -> others_simpl - | Some e -> e::others_simpl + | None -> bag, others_simpl + | Some e -> bag, e::others_simpl ) ;; -let simplify_equalities eq_uri env equalities = - debug_print +let simplify_equalities bag eq_uri env equalities = + Utils.debug_print (lazy (Printf.sprintf "equalities:\n%s\n" (String.concat "\n" (List.map Equality.string_of_equality equalities)))); - debug_print (lazy "SIMPLYFYING EQUALITIES..."); +Utils.debug_print (lazy "SIMPLYFYING EQUALITIES..."); match equalities with - | [] -> [] + | [] -> bag, [] | hd::tl -> - let res = - List.rev (simpl eq_uri env hd tl []) - in - debug_print + let bag, res = simpl bag eq_uri env hd tl [] in + let res = List.rev res in + Utils.debug_print (lazy (Printf.sprintf "equalities AFTER:\n%s\n" (String.concat "\n" (List.map Equality.string_of_equality res)))); - res + bag, res ;; let print_goals goals = @@ -907,48 +774,75 @@ let print_goals goals = let pp_goal_set msg goals names = let active_goals, passive_goals = goals in - prerr_endline ("////" ^ msg); - prerr_endline ("ACTIVE G: " ^ + debug_print (lazy ("////" ^ msg)); + debug_print (lazy ("ACTIVE G: " ^ (String.concat "\n " (List.map (fun (_,_,g) -> CicPp.pp g names) - active_goals))); - prerr_endline ("PASSIVE G: " ^ + active_goals)))); + debug_print (lazy ("PASSIVE G: " ^ (String.concat "\n " (List.map (fun (_,_,g) -> CicPp.pp g names) - passive_goals))) + passive_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 check_if_goal_is_subsumed bag ((_,ctx,_) as env) table (goalproof,menv,ty) = +(* let names = Utils.names_of_context ctx in *) match ty with | Cic.Appl[Cic.MutInd(uri,_,_);eq_ty;left;right] when LibraryObjects.is_eq_URI uri -> - (let goal_equation = - Equality.mk_equality - (0,Equality.Exact (Cic.Implicit None),(eq_ty,left,right,Eq),menv) + (let bag, goal_equation = + Equality.mk_equality bag + (0,Equality.Exact (Cic.Implicit None),(eq_ty,left,right,Utils.Eq),menv) in -(* match Indexing.subsumption env table goal_equation with*) + (* match Indexing.subsumption env table goal_equation with *) match Indexing.unification env table goal_equation with | Some (subst, equality, swapped ) -> +(* prerr_endline - ("GOAL SUBSUMED IS: " ^ Equality.string_of_equality goal_equation ~env); + ("GOAL SUBSUMED IS: "^Equality.string_of_equality goal_equation ~env); prerr_endline - ("GOAL IS SUBSUMED BY: " ^ Equality.string_of_equality equality ~env); - prerr_endline ("SUBST:" ^ Subst.ppsubst ~names subst); + ("GOAL IS SUBSUMED BY: "^Equality.string_of_equality equality ~env); + prerr_endline ("SUBST:"^Subst.ppsubst ~names subst); +*) let (_,p,(ty,l,r,_),m,id) = Equality.open_equality equality in let cicmenv = Subst.apply_subst_metasenv subst (m @ menv) in - let p = + let bag, p = if swapped then - Equality.symmetric eq_ty l id uri m + Equality.symmetric bag eq_ty l id uri m else - p + bag, p in - Some (goalproof, p, id, subst, cicmenv) - | None -> None) - | _ -> None + bag, Some (goalproof, p, id, subst, cicmenv) + | None -> + bag, None) + | _ -> bag, None +;; + +let find_all_subsumed bag env table (goalproof,menv,ty) = + match ty with + | Cic.Appl[Cic.MutInd(uri,_,_);eq_ty;left;right] + when LibraryObjects.is_eq_URI uri -> + let bag, goal_equation = + (Equality.mk_equality bag + (0,Equality.Exact (Cic.Implicit None),(eq_ty,left,right,Utils.Eq),menv)) + in + List.fold_right + (fun (subst, equality, swapped) (bag,acc) -> + let (_,p,(ty,l,r,_),m,id) = Equality.open_equality equality in + let cicmenv = Subst.apply_subst_metasenv subst (m @ menv) in + if Utils.debug_metas then + Indexing.check_for_duplicates cicmenv "from subsumption"; + let bag, p = + if swapped then + Equality.symmetric bag eq_ty l id uri m + else + bag, p + in + bag, (goalproof, p, id, subst, cicmenv)::acc) + (Indexing.subsumption_all env table goal_equation) (bag,[]) + (* (Indexing.unification_all env table goal_equation) *) + | _ -> assert false ;; + let check_if_goal_is_identity env = function | (goalproof,m,Cic.Appl[Cic.MutInd(uri,_,ens);eq_ty;left;right]) when left = right && LibraryObjects.is_eq_URI uri -> @@ -959,133 +853,98 @@ let check_if_goal_is_identity env = function (let _,context,_ = env in try let s,m,_ = - Inference.unification m m context left right CicUniv.empty_ugraph + Founif.unification [] m context left right CicUniv.empty_ugraph in let reflproof = Equality.Exact (Equality.refl_proof uri eq_ty left) in let m = Subst.apply_subst_metasenv s m in Some (goalproof, reflproof, 0, s,m) - with _ -> None) + with CicUnification.UnificationFailure _ -> None) | _ -> None ;; -let rec check goal = function - | [] -> None +let rec check b goal = function + | [] -> b, None | f::tl -> - match f goal with - | None -> check goal tl - | (Some p) as ok -> ok + match f b goal with + | b, None -> check b goal tl + | b, (Some _ as ok) -> b, ok ;; -let simplify_goal_set env goals ?passive active = +let simplify_goal_set bag env goals 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 = + (* prova:tengo le passive semplificate + let passive_goals = + List.map (fun g -> snd (simplify_goal env g active)) passive_goals + in *) List.fold_left - (fun acc goal -> - match simplify_goal env goal ?passive active with + (fun (acc_a,acc_p) goal -> + match simplify_goal bag env goal active with | changed, g -> - if changed then prerr_endline "???????????????cambiato ancora"; - 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 - 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)) - *) + if changed then + if find g acc_p then acc_a,acc_p else acc_a,g::acc_p + else + if find g acc_a then acc_a,acc_p else g::acc_a,acc_p) + ([],passive_goals) active_goals ;; -let check_if_goals_set_is_solved env active goals = +let check_if_goals_set_is_solved bag env active passive goals = let active_goals, passive_goals = goals in List.fold_left - (fun proof goal -> + (fun (bag, proof) goal -> match proof with - | Some p -> proof + | Some p -> bag, proof | None -> - check goal [ - check_if_goal_is_identity env; - check_if_goal_is_subsumed env (snd active)]) - None active_goals + check bag goal [ + (fun b x -> b, check_if_goal_is_identity env x); + (fun bag -> check_if_goal_is_subsumed bag env (snd active)); + (fun bag -> check_if_goal_is_subsumed bag env (last passive)) + ]) + (bag,None) (active_goals @ passive_goals) ;; -let infer_goal_set env active goals = +let infer_goal_set bag env active goals = let active_goals, passive_goals = goals in - let rec aux = function - | [] -> active_goals, [] + let rec aux bag = function + | [] -> bag, (active_goals, []) | hd::tl -> - let changed,selected = simplify_goal env hd active in - if changed then - prerr_endline ("--------------- goal semplificato"); - let (_,_,t1) = selected in + let changed, selected = simplify_goal bag env hd active in + let (_,m1,t1) = selected in let already_in = List.exists (fun (_,_,t) -> Equality.meta_convertibility t t1) active_goals in if already_in then - aux tl + aux bag tl else let passive_goals = tl in - let new_passive_goals = - if Utils.metas_of_term t1 = [] then passive_goals + let bag, new_passive_goals = + if Utils.metas_of_term t1 = [] then + bag, passive_goals else - let newmaxmeta,new' = - Indexing.superposition_left env (snd active) selected - !maxmeta + let bag, new' = + Indexing.superposition_left bag env (snd active) selected in - maxmeta := newmaxmeta; - passive_goals @ new' + bag, passive_goals @ new' in - selected::active_goals, new_passive_goals + bag, (selected::active_goals, new_passive_goals) in - aux passive_goals + aux bag passive_goals ;; -(* old -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_passive_goals = - if CicUtil.is_meta_closed t1 then - passive_goals - else - let new' = Indexing.superposition_left env (snd active) selected in - passive_goals @ new' - in - selected::active_goals, new_passive_goals - | _::tl -> aux tl - in - aux passive_goals -;; -*) - -let infer_goal_set_with_current env current goals active = - let active_goals, passive_goals = goals in - let active_goals, _ = - simplify_goal_set env goals active - in +let infer_goal_set_with_current bag env current goals active = + let active_goals, passive_goals = simplify_goal_set bag env goals active in let l,table,_ = build_table [current] in - active_goals, - List.fold_left - (fun acc g -> - let newmaxmeta, new' = Indexing.superposition_left env table g !maxmeta in - maxmeta := newmaxmeta; - acc @ new') - passive_goals active_goals + let bag, passive_goals = + List.fold_left + (fun (bag, acc) g -> + let bag, new' = Indexing.superposition_left bag env table g in + bag, acc @ new') + (bag, passive_goals) active_goals + in + bag, active_goals, passive_goals ;; let ids_of_goal g = @@ -1101,13 +960,66 @@ let ids_of_goal_set (ga,gp) = let size_of_goal_set_a (l,_) = List.length l;; let size_of_goal_set_p (_,l) = List.length l;; + +let pp_goals label goals context = + let names = Utils.names_of_context context in + List.iter + (fun _,_,g -> + debug_print (lazy + (Printf.sprintf "Current goal: %s = %s\n" label (CicPp.pp g names)))) + (fst goals); + List.iter + (fun _,_,g -> + debug_print (lazy + (Printf.sprintf "PASSIVE goal: %s = %s\n" label (CicPp.pp g names)))) + (snd goals); +;; + +let print_status iterno goals active passive = + debug_print (lazy + (Printf.sprintf "\n%d #ACTIVES: %d #PASSIVES: %d #GOALSET: %d(%d)" + iterno (size_of_active active) (size_of_passive passive) + (size_of_goal_set_a goals) (size_of_goal_set_p goals))) +;; + +let add_to_active_aux bag active passive env eq_uri current = + debug_print (lazy ("Adding to actives : " ^ + Equality.string_of_equality ~env current)); + match forward_simplify bag eq_uri env current active with + | bag, None -> None, active, passive, bag + | bag, Some current -> + let bag, new' = infer bag eq_uri env current active in + let active = + let al, tbl = active in + al @ [current], Indexing.index tbl current + in + let rec simplify bag new' active passive = + let bag, new' = + forward_simplify_new bag eq_uri env new' active + in + let bag, active, newa, pruned = + backward_simplify bag eq_uri env new' active + in + let passive = + List.fold_left (filter_dependent bag) passive pruned + in + match newa with + | None -> bag, active, passive, new' + | Some p -> simplify bag (new' @ p) active passive + in + let bag, active, passive, new' = + simplify bag new' active passive + in + let passive = add_to_passive passive new' [] in + Some new', active, passive, bag +;; (** given-clause algorithm with full reduction strategy: NEW implementation *) (* here goals is a set of goals in OR *) let given_clause - eq_uri ((_,context,_) as env) goals theorems passive active max_iterations max_time + bag eq_uri ((_,context,_) as env) goals passive active + goal_steps saturation_steps max_time = - let names = names_of_context context in let initial_time = Unix.gettimeofday () in let iterations_left iterno = let now = Unix.gettimeofday () in @@ -1119,27 +1031,19 @@ let given_clause 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") + let rec step bag goals passive active g_iterno s_iterno = + if g_iterno > goal_steps && s_iterno > saturation_steps then + (ParamodulationFailure ("No more iterations to spend",active,passive,bag)) else if Unix.gettimeofday () > max_time then - (ParamodulationFailure "No more time to spend") + (ParamodulationFailure ("No more time to spend",active,passive,bag)) 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 -*) let _ = - 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)) + print_status (max g_iterno s_iterno) goals active passive +(* Printf.eprintf ".%!"; *) in (* PRUNING OF PASSIVE THAT WILL NEVER BE PROCESSED *) let passive = - let selection_estimate = iterations_left iterno in + let selection_estimate = iterations_left (max g_iterno s_iterno) in let kept = size_of_passive passive in if kept > selection_estimate then begin @@ -1150,121 +1054,79 @@ let given_clause passive in kept_clauses := (size_of_passive passive) + (size_of_active active); - let goals = infer_goal_set env active goals 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)); - ParamodulationSuccess p - | None -> + let bag, goals = + if g_iterno < goal_steps then + infer_goal_set bag env active goals + else + bag, goals + in + match check_if_goals_set_is_solved bag env active passive goals with + | bag, Some p -> + debug_print (lazy + (Printf.sprintf "\nFound a proof in: %f\n" + (Unix.gettimeofday() -. initial_time))); + ParamodulationSuccess (p,active,passive,bag) + | bag, None -> (* SELECTION *) if passive_is_empty passive then if no_more_passive_goals goals then - ParamodulationFailure "No more passive equations/goals" + ParamodulationFailure + ("No more passive equations/goals",active,passive,bag) (*maybe this is a success! *) else - step goals theorems passive active (iterno+1) + step bag goals passive active (g_iterno+1) (s_iterno+1) else begin (* COLLECTION OF GARBAGED EQUALITIES *) - if iterno mod 40 = 0 then - begin + let bag = + if max g_iterno s_iterno mod 40 = 0 then + (print_status (max g_iterno s_iterno) goals active passive; let active = List.map Equality.id_of (fst active) in - let passive = List.map Equality.id_of (fst (fst passive)) in + let passive = List.map Equality.id_of (fst3 passive) in let goal = ids_of_goal_set goals in - Equality.collect active passive goal - end; - let current, passive = select env goals passive in - let _ = - List.iter - (fun _,_,g -> - prerr_endline (Printf.sprintf "Current goal = %s\n" - (CicPp.pp g names))) - (fst goals); - List.iter - (fun _,_,g -> - prerr_endline (Printf.sprintf "Passive goal = %s\n" - (CicPp.pp g names))) - (snd goals); - prerr_endline (Printf.sprintf "Selected = %s\n" - (Equality.string_of_equality ~env current)) - in - (* SIMPLIFICATION OF CURRENT *) - let res = - forward_simplify eq_uri env (Positive, current) active + Equality.collect bag active passive goal) + else + bag in - match res with - | None -> step goals theorems passive active (iterno+1) - | Some current -> - (* GENERATION OF NEW EQUATIONS *) - prerr_endline "infer"; - let new' = infer eq_uri env current active in - prerr_endline "infer goal"; -(* - 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)); - ParamodulationSuccess p - | None -> -*) - let active = - let al, tbl = active in - al @ [current], Indexing.index tbl current - in - let goals = - infer_goal_set_with_current env current goals active - in - (* FORWARD AND BACKWARD SIMPLIFICATION *) - prerr_endline "fwd/back simpl"; - let rec simplify new' active passive = - let new' = - forward_simplify_new eq_uri env new' ~passive active - in - let active, passive, newa, retained, pruned = - backward_simplify eq_uri 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 - let _ = <:start> in - let rc = simplify_goal_set env goals ~passive (a,b) in - let _ = <:stop> in - rc - in - let passive = add_to_passive passive new' in - step goals theorems passive active (iterno+1) + if s_iterno > saturation_steps then + step bag goals passive active (g_iterno+1) (s_iterno+1) + (* ParamodulationFailure ("max saturation steps",active,passive,bag) *) + else + let current, passive = select env goals passive in + match add_to_active_aux bag active passive env eq_uri current with + | None, active, passive, bag -> + step bag goals passive active (g_iterno+1) (s_iterno+1) + | Some new', active, passive, bag -> + let bag, active_goals, passive_goals = + infer_goal_set_with_current bag env current goals active + in + let goals = + let a,b,_ = build_table new' in + let rc = + simplify_goal_set bag env (active_goals,passive_goals) (a,b) + in + rc + in + step bag goals passive active (g_iterno+1) (s_iterno+1) end in - step goals theorems passive active 1 + step bag goals passive active 0 0 ;; -let rec saturate_equations eq_uri env goal accept_fun passive active = +let rec saturate_equations bag eq_uri env goal accept_fun passive active = elapsed_time := Unix.gettimeofday () -. !start_time; if !elapsed_time > !time_limit then - (active, passive) + bag, active, passive else let current, passive = select env ([goal],[]) passive in - let res = forward_simplify eq_uri env (Positive, current) ~passive active in + let bag, res = forward_simplify bag eq_uri env current active in match res with | None -> - saturate_equations eq_uri env goal accept_fun passive active + saturate_equations bag eq_uri env goal accept_fun passive active | Some current -> - debug_print (lazy (Printf.sprintf "selected: %s" + Utils.debug_print (lazy (Printf.sprintf "selected: %s" (Equality.string_of_equality ~env current))); - let new' = infer eq_uri env current active in + let bag, new' = infer bag eq_uri env current active in let active = if Equality.is_identity env current then active else @@ -1273,21 +1135,19 @@ let rec saturate_equations eq_uri env goal accept_fun passive active = in (* alla fine new' contiene anche le attive semplificate! * quindi le aggiungo alle passive insieme alle new *) - let rec simplify new' active passive = - let new' = forward_simplify_new eq_uri env new' ~passive active in - let active, passive, newa, retained, pruned = - backward_simplify eq_uri env new' ~passive active in + let rec simplify bag new' active passive = + let bag, new' = forward_simplify_new bag eq_uri env new' active in + let bag, active, newa, pruned = + backward_simplify bag eq_uri env new' 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 + List.fold_left (filter_dependent bag) passive pruned in + match newa with + | None -> bag, active, passive, new' + | Some p -> simplify bag (new' @ p) active passive in - let active, passive, new' = simplify new' active passive in + let bag, active, passive, new' = simplify bag new' active passive in let _ = - debug_print + Utils.debug_print (lazy (Printf.sprintf "active:\n%s\n" (String.concat "\n" @@ -1296,7 +1156,7 @@ let rec saturate_equations eq_uri env goal accept_fun passive active = (fst active))))) in let _ = - debug_print + Utils.debug_print (lazy (Printf.sprintf "new':\n%s\n" (String.concat "\n" @@ -1305,181 +1165,14 @@ let rec saturate_equations eq_uri env goal accept_fun passive active = (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 eq_uri env goal accept_fun passive active + let passive = add_to_passive passive new' [] in + saturate_equations bag eq_uri 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 - let module PET = ProofEngineTypes in - let module PP = CicPp in - let proof = None, (1, [], term)::metasenv, C.Meta (1, []), term in - let status = PET.apply_tactic (PrimitiveTactics.intros_tac ()) (proof, 1) in - let proof, goals = status in - let goal' = List.nth goals 0 in - let _, metasenv, meta_proof, _ = proof in - let _, context, goal = CicUtil.lookup_meta goal' metasenv in - let eq_indexes, equalities, maxm = find_equalities context proof in - let lib_eq_uris, library_equalities, maxm = - - find_library_equalities dbd context (proof, goal') (maxm+2) - in - let library_equalities = List.map snd library_equalities in - maxmeta := maxm+2; (* TODO ugly!! *) - let irl = CicMkImplicit.identity_relocation_list_for_metavariable context in - let new_meta_goal, metasenv, type_of_goal = - let _, context, ty = CicUtil.lookup_meta goal' metasenv in - debug_print - (lazy - (Printf.sprintf "\n\nTIPO DEL GOAL: %s\n\n" (CicPp.ppterm ty))); - Cic.Meta (maxm+1, irl), - (maxm+1, context, ty)::metasenv, - ty - in - let env = (metasenv, context, ugraph) in - let t1 = Unix.gettimeofday () in - let theorems = - if full then - let theorems = find_library_theorems dbd env (proof, goal') lib_eq_uris in - let context_hyp = find_context_hypotheses env eq_indexes in - context_hyp @ theorems, [] - else - let refl_equal = - let us = UriManager.string_of_uri (LibraryObjects.eq_URI ()) in - UriManager.uri_of_string (us ^ "#xpointer(1/1/1)") - in - let t = CicUtil.term_of_uri refl_equal in - let ty, _ = CicTypeChecker.type_of_aux' [] [] t CicUniv.empty_ugraph in - [(t, ty, [])], [] - in - let t2 = Unix.gettimeofday () in - debug_print - (lazy - (Printf.sprintf "Time to retrieve theorems: %.9f\n" (t2 -. t1))); - let _ = - debug_print - (lazy - (Printf.sprintf - "Theorems:\n-------------------------------------\n%s\n" - (String.concat "\n" - (List.map - (fun (t, ty, _) -> - Printf.sprintf - "Term: %s, type: %s" (CicPp.ppterm t) (CicPp.ppterm ty)) - (fst theorems))))) - in - (*try*) - 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 - let passive = make_passive equalities in - Printf.printf "\ncurrent goal: %s\n" - (let _, _, g = goal in CicPp.ppterm g); - Printf.printf "\ncontext:\n%s\n" (PP.ppcontext context); - Printf.printf "\nmetasenv:\n%s\n" (print_metasenv metasenv); - Printf.printf "\nequalities:\n%s\n" - (String.concat "\n" - (List.map - (Equality.string_of_equality ~env) equalities)); -(* (equalities @ library_equalities))); *) - print_endline "--------------------------------------------------"; - let start = Unix.gettimeofday () in - print_endline "GO!"; - start_time := Unix.gettimeofday (); - let res = - let goals = make_goals goal in - (if !use_fullred then given_clause_fullred else given_clause_fullred) - dbd env goals theorems passive active - in - let finish = Unix.gettimeofday () in - let _ = - match res with - | ParamodulationFailure -> - Printf.printf "NO proof found! :-(\n\n" - | 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 eq -> - let (_, _, _, menv,_) = Equality.open_equality eq in - m @ menv) - metasenv equalities - in - let _ = - (*try*) - let ty, ug = - CicTypeChecker.type_of_aux' newmetasenv context proof ugraph - in - print_endline (string_of_float (finish -. start)); - Printf.printf - "\nGOAL was: %s\nPROOF has type: %s\nconvertible?: %s\n\n" - (CicPp.pp type_of_goal names) (CicPp.pp ty names) - (string_of_bool - (fst (CicReduction.are_convertible - context type_of_goal ty ug))); - (*with e -> - Printf.printf "\nEXCEPTION!!! %s\n" (Printexc.to_string e); - Printf.printf "MAXMETA USED: %d\n" !maxmeta; - print_endline (string_of_float (finish -. start));*) - in - () - - | ParamodulationSuccess None -> - Printf.printf "Success, but no proof?!?\n\n" - in - if Utils.time then - begin - prerr_endline - ((Printf.sprintf ("infer_time: %.9f\nforward_simpl_time: %.9f\n" ^^ - "forward_simpl_new_time: %.9f\n" ^^ - "backward_simpl_time: %.9f\n") - !infer_time !forward_simpl_time !forward_simpl_new_time - !backward_simpl_time) ^ - (Printf.sprintf "passive_maintainance_time: %.9f\n" - !passive_maintainance_time) ^ - (Printf.sprintf " successful unification/matching time: %.9f\n" - !Indexing.match_unif_time_ok) ^ - (Printf.sprintf " failed unification/matching time: %.9f\n" - !Indexing.match_unif_time_no) ^ - (Printf.sprintf " indexing retrieval time: %.9f\n" - !Indexing.indexing_retrieval_time) ^ - (Printf.sprintf " demodulate_term.build_newtarget_time: %.9f\n" - !Indexing.build_newtarget_time) ^ - (Printf.sprintf "derived %d clauses, kept %d clauses.\n" - !derived_clauses !kept_clauses)) - end -(* - with exc -> - print_endline ("EXCEPTION: " ^ (Printexc.to_string exc)); - raise exc -*) -;; -*) - let default_depth = !maxdepth and default_width = !maxwidth;; let reset_refs () = - maxmeta := 0; symbols_counter := 0; weight_age_counter := !weight_age_ratio; processed_clauses := 0; @@ -1493,9 +1186,29 @@ let reset_refs () = passive_maintainance_time := 0.; derived_clauses := 0; kept_clauses := 0; - Equality.reset (); ;; +let add_to_active bag active passive env ty term newmetas = + reset_refs (); + match LibraryObjects.eq_URI () with + | None -> active, passive, bag + | Some eq_uri -> + try + let bag, current = Equality.equality_of_term bag term ty newmetas in + let w,_,_,_,_ = Equality.open_equality current in + if w > 100 then + (HLog.debug + ("skipping giant " ^ CicPp.ppterm term ^ " of weight " ^ + string_of_int w); active, passive, bag) + else + let bag, current = Equality.fix_metas bag current in + match add_to_active_aux bag active passive env eq_uri current with + | _,a,p,b -> a,p,b + with + | Equality.TermIsNotAnEquality -> active, passive, bag +;; + + let eq_of_goal = function | Cic.Appl [Cic.MutInd(uri,0,_);_;_;_] when LibraryObjects.is_eq_URI uri -> uri @@ -1508,131 +1221,221 @@ let eq_and_ty_of_goal = function | _ -> raise (ProofEngineTypes.Fail (lazy ("The goal is not an equality "))) ;; -let saturate - caso_strano - dbd ?(full=false) ?(depth=default_depth) ?(width=default_width) status = - let module C = Cic in - reset_refs (); - Indexing.init_index (); - maxdepth := depth; - maxwidth := width; -(* CicUnification.unif_ty := false;*) +(* fix proof takes in input a term and try to build a metasenv for it *) + +let fix_proof metasenv context all_implicits p = + let rec aux metasenv n p = + match p with + | Cic.Meta (i,_) -> + if all_implicits then + metasenv,Cic.Implicit None + else + let irl = + CicMkImplicit.identity_relocation_list_for_metavariable context + in + let meta = CicSubstitution.lift n (Cic.Meta (i,irl)) in + let metasenv = + try + let _ = CicUtil.lookup_meta i metasenv in metasenv + with CicUtil.Meta_not_found _ -> + debug_print (lazy ("not found: "^(string_of_int i))); + let metasenv,j = CicMkImplicit.mk_implicit_type metasenv [] context in + (i,context,Cic.Meta(j,irl))::metasenv + in + metasenv,meta + | Cic.Appl l -> + let metasenv,l= + List.fold_right + (fun a (metasenv,l) -> + let metasenv,a' = aux metasenv n a in + metasenv,a'::l) + l (metasenv,[]) + in metasenv,Cic.Appl l + | Cic.Lambda(name,s,t) -> + let metasenv,s = aux metasenv n s in + let metasenv,t = aux metasenv (n+1) t in + metasenv,Cic.Lambda(name,s,t) + | Cic.Prod(name,s,t) -> + let metasenv,s = aux metasenv n s in + let metasenv,t = aux metasenv (n+1) t in + metasenv,Cic.Prod(name,s,t) + | Cic.LetIn(name,s,ty,t) -> + let metasenv,s = aux metasenv n s in + let metasenv,ty = aux metasenv n ty in + let metasenv,t = aux metasenv (n+1) t in + metasenv,Cic.LetIn(name,s,ty,t) + | Cic.Const(uri,ens) -> + let metasenv,ens = + List.fold_right + (fun (v,a) (metasenv,ens) -> + let metasenv,a' = aux metasenv n a in + metasenv,(v,a')::ens) + ens (metasenv,[]) + in + metasenv,Cic.Const(uri,ens) + | t -> metasenv,t + in + aux metasenv 0 p +;; + +let fix_metasenv context metasenv = + List.fold_left + (fun m (i,c,t) -> + let m,t = fix_proof m context false t in + let m = List.filter (fun (j,_,_) -> j<>i) m in + (i,context,t)::m) + metasenv metasenv +;; + + +(* status: input proof status + * goalproof: forward steps on goal + * newproof: backward steps + * subsumption_id: the equation used if goal is closed by subsumption + * (0 if not closed by subsumption) (DEBUGGING: can be safely removed) + * subsumption_subst: subst to make newproof and goalproof match + * proof_menv: final metasenv + *) + +let build_proof + bag status + goalproof newproof subsumption_id subsumption_subst proof_menv += + if proof_menv = [] then debug_print (lazy "+++++++++++++++VUOTA") + else debug_print (lazy (CicMetaSubst.ppmetasenv [] proof_menv)); let proof, goalno = status in - let uri, metasenv, meta_proof, term_to_prove = proof in + let uri, metasenv, _subst, meta_proof, term_to_prove, attrs = proof in let _, context, type_of_goal = CicUtil.lookup_meta goalno metasenv in let eq_uri = eq_of_goal type_of_goal in - let names = names_of_context context in - let eq_indexes, equalities, maxm = find_equalities context proof in - let ugraph = CicUniv.empty_ugraph in - let env = (metasenv, context, ugraph) in - let cleaned_goal = Utils.remove_local_context type_of_goal in - let goal = [], List.filter (fun (i,_,_)->i<>goalno) metasenv, cleaned_goal in - let res, time = - let t1 = Unix.gettimeofday () in - let lib_eq_uris, library_equalities, maxm = - find_library_equalities caso_strano dbd context (proof, goalno) (maxm+2) - in - let library_equalities = List.map snd library_equalities in - let t2 = Unix.gettimeofday () in - maxmeta := maxm+2; - let equalities = - simplify_equalities eq_uri env (equalities@library_equalities) - in - debug_print - (lazy - (Printf.sprintf "Time to retrieve equalities: %.9f\n" (t2 -. t1))); - let t1 = Unix.gettimeofday () in - let theorems = - if full then - 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 - let refl_equal = LibraryObjects.eq_refl_URI ~eq:eq_uri in - let t = CicUtil.term_of_uri refl_equal in - let ty, _ = CicTypeChecker.type_of_aux' [] [] t CicUniv.empty_ugraph in - [(t, ty, [])], [] - in - let t2 = Unix.gettimeofday () in - let _ = - debug_print - (lazy - (Printf.sprintf - "Theorems:\n-------------------------------------\n%s\n" - (String.concat "\n" - (List.map - (fun (t, ty, _) -> - Printf.sprintf - "Term: %s, type: %s" - (CicPp.ppterm t) (CicPp.ppterm ty)) - (fst theorems))))); - debug_print - (lazy - (Printf.sprintf "Time to retrieve theorems: %.9f\n" (t2 -. t1))); - in - let active = make_active () in - let passive = make_passive equalities in - let start = Unix.gettimeofday () in - let res = + let names = Utils.names_of_context context in + debug_print (lazy "Proof:"); + debug_print (lazy + (Equality.pp_proof bag names goalproof newproof subsumption_subst + subsumption_id type_of_goal)); (* - let goals = make_goals goal in - given_clause_fullred dbd env goals theorems passive active + prerr_endline ("max weight: " ^ + (string_of_int (Equality.max_weight goalproof newproof))); *) - let goals = make_goal_set goal in - let max_iterations = 10000 in - let max_time = Unix.gettimeofday () +. 300. (* minutes *) in - given_clause - eq_uri env goals theorems passive active max_iterations max_time - in - let finish = Unix.gettimeofday () in - (res, finish -. start) + (* generation of the CIC proof *) + (* let metasenv' = List.filter (fun i,_,_ -> i<>goalno) metasenv in *) + let side_effects = + List.filter (fun i -> i <> goalno) + (ProofEngineHelpers.compare_metasenvs + ~newmetasenv:metasenv ~oldmetasenv:proof_menv) in + let goal_proof, side_effects_t = + let initial = Equality.add_subst subsumption_subst newproof in + Equality.build_goal_proof bag + eq_uri goalproof initial type_of_goal side_effects + context proof_menv in - match res with - | 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!"; - prerr_endline - (Equality.pp_proof names goalproof newproof subsumption_subst - subsumption_id type_of_goal); - 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 - let goal_proof, side_effects_t = - let initial = Equality.add_subst subsumption_subst newproof in - Equality.build_goal_proof - eq_uri goalproof initial type_of_goal side_effects - in - prerr_endline ("PROOF: " ^ CicPp.pp goal_proof names); - let goal_proof = Subst.apply_subst subsumption_subst goal_proof in +(* Equality.draw_proof bag names goalproof newproof subsumption_id; *) + let goal_proof = Subst.apply_subst subsumption_subst goal_proof in + (* assert (metasenv=[]); *) + let real_menv = fix_metasenv context (proof_menv@metasenv) in + let real_menv,goal_proof = + fix_proof real_menv context false goal_proof in +(* + let real_menv,fixed_proof = fix_proof proof_menv context false goal_proof in + (* prerr_endline ("PROOF: " ^ CicPp.pp goal_proof names); *) +*) + let pp_error goal_proof names error exn = + prerr_endline "THE PROOF DOES NOT TYPECHECK! "; + prerr_endline (CicPp.pp goal_proof names); + prerr_endline "THE PROOF DOES NOT TYPECHECK!"; + prerr_endline error; + prerr_endline "THE PROOF DOES NOT TYPECHECK! "; + raise exn + in + let old_insert_coercions = !CicRefine.insert_coercions in + let goal_proof,goal_ty,real_menv,_ = + (* prerr_endline ("parte la refine per: " ^ (CicPp.pp goal_proof names)); *) + try + debug_print (lazy (CicPp.ppterm goal_proof)); + CicRefine.insert_coercions := false; + let res = + CicRefine.type_of_aux' + real_menv context goal_proof CicUniv.empty_ugraph + in + CicRefine.insert_coercions := old_insert_coercions; + res + with + | CicRefine.RefineFailure s + | CicRefine.Uncertain s + | CicRefine.AssertFailure s as exn -> + CicRefine.insert_coercions := old_insert_coercions; + pp_error goal_proof names (Lazy.force s) exn + | CicUtil.Meta_not_found i as exn -> + CicRefine.insert_coercions := old_insert_coercions; + pp_error goal_proof names ("META NOT FOUND: "^string_of_int i) exn + | Invalid_argument "list_fold_left2" as exn -> + CicRefine.insert_coercions := old_insert_coercions; + pp_error goal_proof names "Invalid_argument: list_fold_left2" exn + | exn -> + CicRefine.insert_coercions := old_insert_coercions; + raise exn + in + let subst_side_effects,real_menv,_ = + try + CicUnification.fo_unif_subst [] context real_menv + goal_ty type_of_goal CicUniv.empty_ugraph + with + | CicUnification.UnificationFailure s + | CicUnification.Uncertain s + | CicUnification.AssertFailure s -> assert false + (* fail "Maybe the local context of metas in the goal was not an IRL" s *) + in + Utils.debug_print (lazy "+++++++++++++ FINE UNIF"); + let final_subst = + (goalno,(context,goal_proof,type_of_goal))::subst_side_effects + in +(* + let metas_of_proof = Utils.metas_of_term goal_proof in +*) + let proof, real_metasenv = + ProofEngineHelpers.subst_meta_and_metasenv_in_proof + proof goalno final_subst + (List.filter (fun i,_,_ -> i<>goalno ) real_menv) + in + let open_goals = + (ProofEngineHelpers.compare_metasenvs + ~oldmetasenv:metasenv ~newmetasenv:real_metasenv) in +(* + let open_goals = + List.map (fun i,_,_ -> i) real_metasenv in +*) + final_subst, proof, open_goals + + +(* + let metas_still_open_in_proof = Utils.metas_of_term goal_proof in -(*prerr_endline (CicPp.pp goal_proof names);*) - (* ?? *) + (* 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..."; + (* prerr_endline "replacing metas..."; *) let irl=CicMkImplicit.identity_relocation_list_for_metavariable context in - let goal_proof_menv, what, with_what,free_meta = + CicMetaSubst.ppmetasenv [] proof_menv; + let what, with_what = List.fold_left - (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) + (fun (acc1,acc2) i -> + (Cic.Meta(i,[]))::acc1, (Cic.Implicit None)::acc2) + ([],[]) + metas_still_open_in_proof +(* (List.filter - (fun (i,_,_) -> List.mem i metas_still_open_in_proof) - proof_menv) + (fun (i,_,_) -> + List.mem i metas_still_open_in_proof + (*&& not(List.mem i metas_still_open_in_goal)*)) + proof_menv) +*) + in + let goal_proof_menv = + 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 @@ -1651,7 +1454,9 @@ let saturate (ProofEngineHelpers.compare_metasenvs ~oldmetasenv:metasenv ~newmetasenv:goal_proof_menv) in -prerr_endline ("freemetas: " ^ String.concat "," (List.map string_of_int free_metas) ); + (* prerr_endline + * ("freemetas: " ^ + * String.concat "," (List.map string_of_int free_metas) ); *) (* check/refine/... build the new proof *) let replaced_goal = ProofEngineReduction.replace @@ -1659,382 +1464,275 @@ prerr_endline ("freemetas: " ^ String.concat "," (List.map string_of_int free_me ~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 - 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 -prerr_endline ("MENVreal_menv: " ^ CicMetaSubst.ppmetasenv [] real_menv); - let _ = + let goal_proof,goal_ty,real_menv,_ = try - CicTypeChecker.type_of_aux' real_menv context goal_proof + CicRefine.type_of_aux' metasenv context goal_proof CicUniv.empty_ugraph with | CicUtil.Meta_not_found _ - | CicTypeChecker.TypeCheckerFailure _ - | CicTypeChecker.AssertFailure _ + | CicRefine.RefineFailure _ + | CicRefine.Uncertain _ + | CicRefine.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 + prerr_endline "+++++++++++++ METASENV"; + prerr_endline + (CicMetaSubst.ppmetasenv [] real_menv); + let subst_side_effects,real_menv,_ = +(* + prerr_endline ("XX type_of_goal " ^ CicPp.ppterm type_of_goal); + prerr_endline ("XX replaced_goal " ^ CicPp.ppterm replaced_goal); + prerr_endline ("XX metasenv " ^ + CicMetaSubst.ppmetasenv [] (metasenv @ free_metas_menv)); +*) + try + CicUnification.fo_unif_subst [] context real_menv + goal_ty type_of_goal CicUniv.empty_ugraph + with + | CicUnification.UnificationFailure s + | CicUnification.Uncertain s + | CicUnification.AssertFailure s -> assert false +(* 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 metas_of_proof = Utils.metas_of_term goal_proof in +*) let proof, real_metasenv = ProofEngineHelpers.subst_meta_and_metasenv_in_proof - proof goalno (CicMetaSubst.apply_subst final_subst) real_menv + proof goalno (CicMetaSubst.apply_subst final_subst) + (List.filter (fun i,_,_ -> i<>goalno ) real_menv) in - let open_goals = + let open_goals = + List.map (fun i,_,_ -> i) real_metasenv in + +(* + HExtlib.list_uniq (List.sort Pervasives.compare metas_of_proof) + in *) +(* 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 -;; - -let retrieve_and_print dbd term metasenv ugraph = - let module C = Cic in - let module T = CicTypeChecker in - let module PET = ProofEngineTypes in - let module PP = CicPp in - let proof = None, (1, [], term)::metasenv, C.Meta (1, []), term in - let status = PET.apply_tactic (PrimitiveTactics.intros_tac ()) (proof, 1) in - let proof, goals = status in - let goal' = List.nth goals 0 in - let uri, metasenv, meta_proof, term_to_prove = proof in - let _, context, type_of_goal = CicUtil.lookup_meta goal' metasenv in - let eq_uri = eq_of_goal type_of_goal in - let eq_indexes, equalities, maxm = find_equalities context proof in - let ugraph = CicUniv.empty_ugraph in - let env = (metasenv, context, ugraph) in - let t1 = Unix.gettimeofday () in - let lib_eq_uris, library_equalities, maxm = - find_library_equalities false dbd context (proof, goal') (maxm+2) in - let t2 = Unix.gettimeofday () in - maxmeta := maxm+2; - let equalities = (* equalities @ *) library_equalities in - debug_print - (lazy - (Printf.sprintf "\n\nequalities:\n%s\n" - (String.concat "\n" - (List.map - (fun (u, e) -> -(* Printf.sprintf "%s: %s" *) - (UriManager.string_of_uri u) -(* (string_of_equality e) *) - ) - equalities)))); - debug_print (lazy "RETR: SIMPLYFYING EQUALITIES..."); - let rec simpl e others others_simpl = - let (u, e) = e in - let active = List.map (fun (u, e) -> (Positive, e)) - (others @ others_simpl) in - let tbl = - List.fold_left - (fun t (_, e) -> Indexing.index t e) - Indexing.empty active - in - let res = forward_simplify eq_uri env (Positive, e) (active, tbl) in - match others with - | hd::tl -> ( - match res with - | None -> simpl hd tl others_simpl - | Some e -> simpl hd tl ((u, e)::others_simpl) - ) - | [] -> ( - match res with - | None -> others_simpl - | Some e -> (u, e)::others_simpl - ) - in - let _equalities = - match equalities with - | [] -> [] - | hd::tl -> - let others = tl in (* List.map (fun e -> (Positive, e)) tl in *) - let res = - List.rev (simpl (*(Positive,*) hd others []) - in - debug_print - (lazy - (Printf.sprintf "\nequalities AFTER:\n%s\n" - (String.concat "\n" - (List.map - (fun (u, e) -> - Printf.sprintf "%s: %s" - (UriManager.string_of_uri u) - (Equality.string_of_equality e) - ) - res)))); - res in - debug_print - (lazy - (Printf.sprintf "Time to retrieve equalities: %.9f\n" (t2 -. t1))) +*) + final_subst, proof, open_goals ;; +*) +(* **************** HERE ENDS THE PARAMODULATION STUFF ******************** *) -let main_demod_equalities dbd term metasenv ugraph = - let module C = Cic in - let module T = CicTypeChecker in - let module PET = ProofEngineTypes in - let module PP = CicPp in - let proof = None, (1, [], term)::metasenv, C.Meta (1, []), term in - let status = PET.apply_tactic (PrimitiveTactics.intros_tac ()) (proof, 1) in - let proof, goals = status in - let goal' = List.nth goals 0 in - let _, metasenv, meta_proof, _ = proof in - let _, context, goal = CicUtil.lookup_meta goal' metasenv in - let eq_uri = eq_of_goal goal in - let eq_indexes, equalities, maxm = find_equalities context proof in - let lib_eq_uris, library_equalities, maxm = - find_library_equalities false dbd context (proof, goal') (maxm+2) - in - let library_equalities = List.map snd library_equalities in - maxmeta := maxm+2; (* TODO ugly!! *) - let irl = CicMkImplicit.identity_relocation_list_for_metavariable context in - let new_meta_goal, metasenv, type_of_goal = - let _, context, ty = CicUtil.lookup_meta goal' metasenv in - debug_print - (lazy - (Printf.sprintf "\n\nTRYING TO INFER EQUALITIES MATCHING: %s\n\n" - (CicPp.ppterm ty))); - Cic.Meta (maxm+1, irl), - (maxm+1, context, ty)::metasenv, - ty - in - let env = (metasenv, context, ugraph) in - (*try*) - let goal = [], [], goal - in - let equalities = - simplify_equalities eq_uri env (equalities@library_equalities) - in - let active = make_active () in - let passive = make_passive equalities in - Printf.printf "\ncontext:\n%s\n" (PP.ppcontext context); - Printf.printf "\nmetasenv:\n%s\n" (print_metasenv metasenv); - Printf.printf "\nequalities:\n%s\n" - (String.concat "\n" - (List.map - (Equality.string_of_equality ~env) equalities)); - print_endline "--------------------------------------------------"; - print_endline "GO!"; - start_time := Unix.gettimeofday (); - if !time_limit < 1. then time_limit := 60.; - let ra, rp = - saturate_equations eq_uri env goal (fun e -> true) passive active - in +(* exported functions *) - let initial = - List.fold_left (fun s e -> EqualitySet.add e s) - EqualitySet.empty equalities - in - let addfun s e = - if not (EqualitySet.mem e initial) then EqualitySet.add e s else s - in - - let passive = - match rp with - | (p, _), _ -> - EqualitySet.elements (List.fold_left addfun EqualitySet.empty p) - in - let active = - let l = fst ra in - 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 (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 (Equality.term_of_equality eq_uri e)) - passive)); - print_newline (); +let pump_actives context bag active passive saturation_steps max_time = + reset_refs(); (* - with e -> - debug_print (lazy ("EXCEPTION: " ^ (Printexc.to_string e))) + let max_l l = + List.fold_left + (fun acc e -> let _,_,_,menv,_ = Equality.open_equality e in + List.fold_left (fun acc (i,_,_) -> max i acc) acc menv) + 0 l in *) +(* let active_l = fst active in *) +(* let passive_l = fst passive in *) +(* let ma = max_l active_l in *) +(* let mp = max_l passive_l in *) + match LibraryObjects.eq_URI () with + | None -> active, passive, bag + | Some eq_uri -> + let env = [],context,CicUniv.empty_ugraph in + (match + given_clause bag eq_uri env ([],[]) + passive active 0 saturation_steps max_time + with + | ParamodulationFailure (_,a,p,b) -> + a, p, b + | ParamodulationSuccess _ -> + assert false) ;; -let demodulate_tac ~dbd ~pattern ((proof,goal)(*s initialstatus*)) = - let curi,metasenv,pbo,pty = proof in - let metano,context,ty = CicUtil.lookup_meta goal metasenv in - let eq_uri = eq_of_goal ty in - let eq_indexes, equalities, maxm = - Inference.find_equalities context proof - in - let lib_eq_uris, library_equalities, maxm = - Inference.find_library_equalities false dbd context (proof, goal) (maxm+2) in - 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 initgoal = [], [], ty in - let env = (metasenv, context, CicUniv.empty_ugraph) in - let equalities = - simplify_equalities eq_uri env (equalities@library_equalities) - in +let all_subsumed bag status active passive = + let proof, goalno = status in + let uri, metasenv, _subst, meta_proof, term_to_prove, attrs = proof in + let _, context, type_of_goal = CicUtil.lookup_meta goalno metasenv in + let env = metasenv,context,CicUniv.empty_ugraph in + let cleaned_goal = Utils.remove_local_context type_of_goal in + let canonical_menv,other_menv = + List.partition (fun (_,c,_) -> c = context) metasenv in + (* prerr_endline ("other menv = " ^ (CicMetaSubst.ppmetasenv [] other_menv)); *) + let metasenv = List.map (fun (i,_,ty)-> (i,[],ty)) canonical_menv in + let goal = [], List.filter (fun (i,_,_)->i<>goalno) metasenv, cleaned_goal in + debug_print (lazy (string_of_int (List.length (fst active)))); + (* we simplify using both actives passives *) let table = List.fold_left - (fun tbl eq -> Indexing.index tbl eq) - Indexing.empty equalities - in - let changed,(newproof,newmetasenv, newty) = - Indexing.demodulation_goal - (metasenv,context,CicUniv.empty_ugraph) table initgoal - in - if changed then - begin - let opengoal = Equality.Exact (Cic.Meta(maxm,irl)) in - let proofterm,_ = - Equality.build_goal_proof eq_uri newproof opengoal ty [] - in - let extended_metasenv = (maxm,context,newty)::metasenv in - let extended_status = - (curi,extended_metasenv,pbo,pty),goal in - let (status,newgoals) = - ProofEngineTypes.apply_tactic - (PrimitiveTactics.apply_tac ~term:proofterm) - extended_status in - (status,maxm::newgoals) - end - else (* if newty = ty then *) - raise (ProofEngineTypes.Fail (lazy "no progress")) - (*else ProofEngineTypes.apply_tactic - (ReductionTactics.simpl_tac ~pattern) - initialstatus*) -;; - -let demodulate_tac ~dbd ~pattern = - ProofEngineTypes.mk_tactic (demodulate_tac ~dbd ~pattern) + (fun (l,tbl) eq -> eq::l,(Indexing.index tbl eq)) + active (list_of_passive passive) in + let (_,_,ty) = goal in + debug_print (lazy ("prima " ^ CicPp.ppterm ty)); + let _,goal = simplify_goal bag env goal table in + let (_,_,ty) = goal in + debug_print (lazy ("in mezzo " ^ CicPp.ppterm ty)); + let bag, subsumed = find_all_subsumed bag env (snd table) goal in + debug_print (lazy ("dopo " ^ CicPp.ppterm ty)); + let subsumed_or_id = + match (check_if_goal_is_identity env goal) with + None -> subsumed + | Some id -> id::subsumed in + debug_print (lazy "dopo subsumed"); + let res = + List.map + (fun + (goalproof,newproof,subsumption_id,subsumption_subst, proof_menv) -> + let subst, proof, gl = + build_proof bag + status goalproof newproof subsumption_id subsumption_subst proof_menv + in + let uri, metasenv, subst, meta_proof, term_to_prove, attrs = proof in + let newmetasenv = + other_menv @ + List.filter + (fun x,_,_ -> not (List.exists (fun y,_,_ -> x=y) other_menv)) metasenv + in + let proof = uri, newmetasenv, subst, meta_proof, term_to_prove, attrs in + (subst, proof,gl)) subsumed_or_id + in + res ;; -let rec find_in_ctx i name = function - | [] -> raise (ProofEngineTypes.Fail (lazy ("Hypothesis not found: " ^ name))) - | Some (Cic.Name name', _)::tl when name = name' -> i - | _::tl -> find_in_ctx (i+1) name tl -;; -let rec position_of i x = function - | [] -> assert false - | j::tl when j <> x -> position_of (i+1) x tl - | _ -> i +let given_clause + bag status active passive goal_steps saturation_steps max_time += + reset_refs(); + let active_l = fst active in + let proof, goalno = status in + let uri, metasenv, _subst, meta_proof, term_to_prove, attrs = proof in + let _, context, type_of_goal = CicUtil.lookup_meta goalno metasenv in + let eq_uri = eq_of_goal type_of_goal in + let cleaned_goal = Utils.remove_local_context type_of_goal in + let metas_occurring_in_goal = CicUtil.metas_of_term cleaned_goal in + let canonical_menv,other_menv = + List.partition (fun (_,c,_) -> c = context) metasenv in + Utils.set_goal_symbols cleaned_goal; (* DISACTIVATED *) + let canonical_menv = + List.map + (fun (i,_,ty)-> (i,[],Utils.remove_local_context ty)) canonical_menv + in + let metasenv' = + List.filter + (fun (i,_,_)-> i<>goalno && List.mem_assoc i metas_occurring_in_goal) + canonical_menv + in + let goal = [], metasenv', cleaned_goal in + let env = metasenv,context,CicUniv.empty_ugraph in + debug_print (lazy ">>>>>> ACTIVES >>>>>>>>"); + List.iter (fun e -> debug_print (lazy (Equality.string_of_equality ~env e))) + active_l; + debug_print (lazy ">>>>>>>>>>>>>>"); + let goals = make_goal_set goal in + match + given_clause bag eq_uri env goals passive active + goal_steps saturation_steps max_time + with + | ParamodulationFailure (msg,a,p,b) -> + if Utils.debug then prerr_endline msg; + None, a, p, b + | ParamodulationSuccess + ((goalproof,newproof,subsumption_id,subsumption_subst, proof_menv),a,p,b) -> + let subst, proof, gl = + build_proof b + status goalproof newproof subsumption_id subsumption_subst proof_menv + in + let uri, metasenv, subst, meta_proof, term_to_prove, attrs = proof in + let proof = uri, other_menv@metasenv, subst, meta_proof, term_to_prove, attrs in + Some (subst, proof,gl),a,p, b ;; -(* Syntax: - * auto superposition target = NAME - * [table = NAME_LIST] [demod_table = NAME_LIST] [subterms_only] - * - * - if table is omitted no superposition will be performed - * - if demod_table is omitted no demodulation will be prformed - * - subterms_only is passed to Indexing.superposition_right - * - * lists are coded using _ (example: H_H1_H2) - *) -let superposition_tac ~target ~table ~subterms_only ~demod_table status = - reset_refs(); - Indexing.init_index (); - let proof,goalno = status in - let curi,metasenv,pbo,pty = proof in - let metano,context,ty = CicUtil.lookup_meta goalno metasenv in - let eq_uri,tty = eq_and_ty_of_goal ty in - let env = (metasenv, context, CicUniv.empty_ugraph) in - let names = names_of_context context in - let eq_index, equalities, maxm = find_equalities context proof in - let eq_what = - let what = find_in_ctx 1 target context in - List.nth equalities (position_of 0 what eq_index) +let solve_narrowing bag status active passive goal_steps = + let proof, goalno = status in + let uri, metasenv, _subst, meta_proof, term_to_prove, attrs = proof in + let _, context, type_of_goal = CicUtil.lookup_meta goalno metasenv in + let cleaned_goal = Utils.remove_local_context type_of_goal in + let metas_occurring_in_goal = CicUtil.metas_of_term cleaned_goal in + let canonical_menv,other_menv = + List.partition (fun (_,c,_) -> c = context) metasenv in + let canonical_menv = + List.map + (fun (i,_,ty)-> (i,[],Utils.remove_local_context ty)) canonical_menv in - let eq_other = - if table <> "" then - let other = - let others = Str.split (Str.regexp "_") table in - List.map (fun other -> find_in_ctx 1 other context) others - in - List.map - (fun other -> List.nth equalities (position_of 0 other eq_index)) - other - else - [] + let metasenv' = + List.filter + (fun (i,_,_)-> i<>goalno && List.mem_assoc i metas_occurring_in_goal) + canonical_menv in - let index = List.fold_left Indexing.index Indexing.empty eq_other in - let maxm, eql = - if table = "" then maxm,[eq_what] else - Indexing.superposition_right - ~subterms_only eq_uri maxm env index eq_what + let goal = [], metasenv', cleaned_goal in + let env = metasenv,context,CicUniv.empty_ugraph in + let goals = + let table = List.fold_left Indexing.index (last passive) (fst active) in + goal :: Indexing.demodulation_all_goal bag env table goal 4 in - prerr_endline ("Superposition right:"); - prerr_endline ("\n eq: " ^ Equality.string_of_equality eq_what ~env); - prerr_endline ("\n table: "); - List.iter (fun e -> prerr_endline (" " ^ Equality.string_of_equality e ~env)) eq_other; - prerr_endline ("\n result: "); - List.iter (fun e -> prerr_endline (Equality.string_of_equality e ~env)) eql; - prerr_endline ("\n result (cut&paste): "); - List.iter - (fun e -> - let t = Equality.term_of_equality eq_uri e in - prerr_endline (CicPp.pp t names)) - eql; - prerr_endline ("\n result proofs: "); - List.iter (fun e -> - prerr_endline (let _,p,_,_,_ = Equality.open_equality e in - let s = match p with Equality.Exact _ -> Subst.empty_subst | Equality.Step (s,_) -> s in - Subst.ppsubst s ^ "\n" ^ - CicPp.pp (Equality.build_proof_term eq_uri [] 0 p) names)) eql; - if demod_table <> "" then - begin - let demod = - let demod = Str.split (Str.regexp "_") demod_table in - List.map (fun other -> find_in_ctx 1 other context) demod - in - let eq_demod = - List.map - (fun demod -> List.nth equalities (position_of 0 demod eq_index)) - demod - in - let table = List.fold_left Indexing.index Indexing.empty eq_demod in - let maxm,eql = - List.fold_left - (fun (maxm,acc) e -> - let maxm,eq = - Indexing.demodulation_equality - eq_uri maxm env table Utils.Positive e + let rec aux newactives newpassives bag = function + | [] -> bag, (newactives, newpassives) + | hd::tl -> + let selected = hd in + let (_,m1,t1) = selected in + let already_in = + List.exists (fun (_,_,t) -> Equality.meta_convertibility t t1) + newactives + in + if already_in then + aux newactives newpassives bag tl + else + let bag, newpassives = + if Utils.metas_of_term t1 = [] then + bag, newpassives + else + let bag, new' = + Indexing.superposition_left bag env (snd active) selected + in + let new' = + List.map + (fun x -> let b, x = simplify_goal bag env x active in x) + new' + in + bag, newpassives @ new' in - maxm,eq::acc) - (maxm,[]) eql - in - let eql = List.rev eql in - prerr_endline ("\n result [demod]: "); - List.iter - (fun e -> prerr_endline (Equality.string_of_equality e ~env)) eql; - prerr_endline ("\n result [demod] (cut&paste): "); - List.iter - (fun e -> - let t = Equality.term_of_equality eq_uri e in - prerr_endline (CicPp.pp t names)) - eql; - end; - proof,[goalno] + aux (selected::newactives) newpassives bag tl + in + let rec do_n bag ag pg = function + | 0 -> None, active, passive, bag + | n -> + let bag, (ag, pg) = aux [] [] bag (ag @ pg) in + match check_if_goals_set_is_solved bag env active passive (ag,pg) with + | bag, None -> do_n bag ag pg (n-1) + | bag, Some (gproof,newproof,subsumption_id,subsumption_subst,pmenv)-> + let subst, proof, gl = + build_proof bag + status gproof newproof subsumption_id subsumption_subst pmenv + in + let uri,metasenv,subst,meta_proof,term_to_prove,attrs = proof in + let proof = + uri, other_menv@metasenv, subst, meta_proof, term_to_prove, attrs + in + Some (subst, proof,gl),active,passive, bag + in + do_n bag [] goals goal_steps ;; -let get_stats () = - <:show> ^ Indexing.get_stats () ^ Inference.get_stats () ^ - Equality.get_stats () + +let add_to_passive eql passives = + add_to_passive passives eql eql ;; +