X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fsoftware%2Fcomponents%2Ftactics%2Fparamodulation%2Fsaturation.ml;h=d4ccf8f42bbcc71f172f6b69085c273437541f36;hb=b0bbbe6ec20a0afa145c1e6d92530105d9d4d7e3;hp=f81556c8f997e7088fbfe006b3552fdec48c8132;hpb=3b7bfb05e6fc1a2ac6864d8f7d959fcda0597d21;p=helm.git diff --git a/helm/software/components/tactics/paramodulation/saturation.ml b/helm/software/components/tactics/paramodulation/saturation.ml index f81556c8f..d4ccf8f42 100644 --- a/helm/software/components/tactics/paramodulation/saturation.ml +++ b/helm/software/components/tactics/paramodulation/saturation.ml @@ -27,10 +27,8 @@ let _profiler = <:profiler<_profiler>>;; (* $Id$ *) -open Inference;; -open Utils;; - (* set to false to disable paramodulation inside auto_tac *) + let connect_to_auto = true;; @@ -79,22 +77,22 @@ type result = | ParamodulationSuccess of new_proof ;; -type goal = Equality.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 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 ;; @@ -121,19 +119,32 @@ module EqualitySet = Set.Make(OrderedEquality);; exception Empty_list;; -let passive_is_empty = function - | ([], _), _ -> true - | _ -> false -;; +type passives = Equality.equality list * EqualitySet.t;; +type actives = Equality.equality list * Indexing.Index.t;; +(* initializes the passive set of equalities + * XXX I think EqualitySet.elements should be ok (to eliminate duplicates) + *) +let make_passive pos = + let set = + List.fold_left (fun s e -> EqualitySet.add e s) EqualitySet.empty pos + in + (*EqualitySet.elements*) pos, set +;; -let size_of_passive ((passive_list, ps), _) = List.length passive_list -(* EqualitySet.cardinal ps *) +let make_active () = [], Indexing.empty ;; +let size_of_passive (passive_list, _) = List.length passive_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 size_of_active (active_list, _) = List.length active_list -;; +let no_more_passive_goals g = match g with | _,[] -> true | _ -> false;; + let age_factor = 0.01;; @@ -147,42 +158,40 @@ let rec select env (goals,_) passive = 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 = 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 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) + 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) + 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 @@ -191,7 +200,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) @@ -200,92 +209,62 @@ 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 - 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 + | hd::tl -> my_min_elt (my_min hd min) tl 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) ;; + 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 pos_list, pos_set = passive in + let passive,no_pruned = List.fold_right - (fun eq ((list,set),table) -> + (fun eq ((list,set),no) -> 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)) + (list, EqualitySet.remove eq set), 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), no) + pos_list (([],pos_set),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 = 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 + assert(pos_head = []); + pos_head @ pos_list @ pos_tail, add pos_set pos ;; (* TODO *) @@ -301,7 +280,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 = @@ -439,26 +418,15 @@ 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 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 + Indexing.demodulation_equality eq_uri !maxmeta env table current + in maxmeta := newmeta; - if Equality.is_identity env newcurrent then - None - else - Some newcurrent + if Equality.is_identity env newcurrent then None else Some newcurrent in let rec demod current = if Utils.debug_metas then @@ -467,59 +435,22 @@ let forward_simplify 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 + res in let res = demod current in match res with | None -> None | Some c -> - if Indexing.in_index active_table c then + if Indexing.in_index active_table c || + check_for_deep_subsumption env 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 -*) + else + res ;; (** simplifies new using active and passive *) -let forward_simplify_new eq_uri env new_pos ?passive active = +let forward_simplify_new eq_uri env new_pos active = if Utils.debug_metas then begin let m,c,u = env in @@ -528,22 +459,15 @@ let forward_simplify_new eq_uri env new_pos ?passive active = 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 demodulate table target = let newmeta, newtarget = - Indexing.demodulation_equality eq_uri !maxmeta env table sign target + Indexing.demodulation_equality eq_uri !maxmeta env table target in maxmeta := newmeta; newtarget in (* we could also demodulate using passive. Currently we don't *) - let new_pos = - List.map (demodulate Positive active_table) new_pos - in + let new_pos = List.map (demodulate active_table) new_pos in let new_pos_set = List.fold_left (fun s e -> @@ -554,63 +478,28 @@ let forward_simplify_new eq_uri env new_pos ?passive active = 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 + 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 rec simplify_goal env goal (active_list, active_table) = 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 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 env goal (active_list, active_table)) ;; -let simplify_goals env goals ?passive active = +let simplify_goals 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 env g active)) p_goals in + let a_goals = List.map (fun g -> snd (simplify_goal env g active)) a_goals in a_goals, p_goals ;; @@ -626,8 +515,7 @@ let backward_simplify_active eq_uri env new_pos new_table min_weight active = equality::res, newn,pruned else match - forward_simplify - eq_uri env (Utils.Positive, equality) (new_pos, new_table) + forward_simplify eq_uri env equality (new_pos, new_table) with | None -> res, newn, id::pruned | Some e -> @@ -669,13 +557,13 @@ let backward_simplify_active eq_uri env new_pos new_table min_weight active = (** simplifies passive using new *) let backward_simplify_passive 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 equality (resl, ress, newn) = let ew, _, _, _ , _ = Equality.open_equality equality in if ew < min_weight then equality::resl, ress, newn else match - forward_simplify eq_uri env (sign, equality) (new_pos, new_table) + forward_simplify eq_uri env equality (new_pos, new_table) with | None -> resl, EqualitySet.remove equality ress, newn | Some e -> @@ -685,7 +573,7 @@ let backward_simplify_passive eq_uri env new_pos new_table min_weight passive = let ress = EqualitySet.remove equality ress in resl, ress, e::newn in - let pl, ps, newp = List.fold_right (f Positive) pl ([], ps, []) in + let pl, ps, newp = List.fold_right f pl ([], ps, []) in let passive_table = List.fold_left (fun tbl e -> Indexing.index tbl e) Indexing.empty pl @@ -704,28 +592,12 @@ let build_table equations = ;; -let backward_simplify eq_uri env new' ?passive active = +let backward_simplify 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 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 *) + active, newa, None, pruned ;; let close eq_uri env new' given = @@ -757,7 +629,7 @@ let is_commutative_law eq = let prova 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" @@ -817,10 +689,7 @@ 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 + | Some ((pn, _), (pp, _), pt) -> pn @ pp, Some pt in let a_theorems, p_theorems = theorems in let demodulate table theorem = @@ -854,7 +723,7 @@ let rec simpl eq_uri env e others others_simpl = (fun t e -> Indexing.index t e) Indexing.empty active in - let res = forward_simplify eq_uri env (Positive,e) (active, tbl) in + let res = forward_simplify eq_uri env e (active, tbl) in match others with | hd::tl -> ( match res with @@ -869,19 +738,19 @@ let rec simpl eq_uri env e others others_simpl = ;; let simplify_equalities eq_uri env equalities = - debug_print + 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 | [] -> [] | hd::tl -> let res = List.rev (simpl eq_uri env hd tl []) in - debug_print + Utils.debug_print (lazy (Printf.sprintf "equalities AFTER:\n%s\n" (String.concat "\n" @@ -901,24 +770,34 @@ let print_goals goals = Printf.sprintf "%d: %s" d (String.concat "; " gl')) goals)) ;; +let pp_goal_set msg goals names = + let active_goals, passive_goals = goals in + prerr_endline ("////" ^ msg); + prerr_endline ("ACTIVE G: " ^ + (String.concat "\n " (List.map (fun (_,_,g) -> CicPp.pp g names) + active_goals))); + prerr_endline ("PASSIVE G: " ^ + (String.concat "\n " (List.map (fun (_,_,g) -> CicPp.pp g names) + 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 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) + (0,Equality.Exact (Cic.Implicit None),(eq_ty,left,right,Utils.Eq),menv) in (* match Indexing.subsumption env table goal_equation with*) match Indexing.unification env table goal_equation with | Some (subst, equality, swapped ) -> prerr_endline - ("GOAL SUBSUMED BY: " ^ Equality.string_of_equality equality); - prerr_endline ("SUBST:" ^ Subst.ppsubst subst); + ("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); let (_,p,(ty,l,r,_),m,id) = Equality.open_equality equality in let cicmenv = Subst.apply_subst_metasenv subst (m @ menv) in let p = @@ -959,29 +838,20 @@ let rec check goal = function | (Some p) as ok -> ok ;; -let simplify_goal_set env goals passive active = +let simplify_goal_set 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 = List.fold_left - (fun acc goal -> - match simplify_goal env goal ~passive active with + (fun (acc_a,acc_p) goal -> + match simplify_goal 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 = @@ -1000,64 +870,45 @@ let check_if_goals_set_is_solved env active goals = let infer_goal_set env active goals = let active_goals, passive_goals = goals in let rec aux = function - | [] -> goals + | [] -> active_goals, [] | hd::tl -> let changed,selected = simplify_goal env hd active in if changed then prerr_endline ("--------------- goal semplificato"); let (_,_,t1) = selected in - if (List.exists - (fun (_,_,t) -> - Equality.meta_convertibility t t1) - active_goals) then aux tl - else - let passive_goals = tl in - let new_passive_goals = - if Utils.metas_of_term t1 = [] then passive_goals - else - let new' = - Indexing.superposition_left env (snd active) selected in - passive_goals @ new' + let already_in = + List.exists (fun (_,_,t) -> Equality.meta_convertibility t t1) + active_goals in - selected::active_goals, new_passive_goals - in - aux 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 + if already_in then + aux tl + else + let passive_goals = tl in + let new_passive_goals = + if Utils.metas_of_term t1 = [] then passive_goals + else + let newmaxmeta,new' = + Indexing.superposition_left env (snd active) selected + !maxmeta + in + maxmeta := newmaxmeta; + passive_goals @ new' + in + selected::active_goals, new_passive_goals 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, +let infer_goal_set_with_current env current goals active = + let active_goals, passive_goals = + simplify_goal_set env goals active + in + let l,table,_ = build_table [current] in + active_goals, List.fold_left (fun acc g -> - let new' = Indexing.superposition_left env table g in + let newmaxmeta, new' = Indexing.superposition_left env table g !maxmeta in + maxmeta := newmaxmeta; acc @ new') passive_goals active_goals ;; @@ -1075,13 +926,26 @@ 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 -> + prerr_endline + (Printf.sprintf "Current goal: %s = %s\n" label (CicPp.pp g names))) + (fst goals); + List.iter + (fun _,_,g -> + prerr_endline + (Printf.sprintf "PASSIVE goal: %s = %s\n" label (CicPp.pp g names))) + (snd goals); +;; (** 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 = - let names = names_of_context context in let initial_time = Unix.gettimeofday () in let iterations_left iterno = let now = Unix.gettimeofday () in @@ -1094,6 +958,7 @@ let given_clause int_of_float iterations_left in let rec step goals theorems passive active iterno = + pp_goals "xxx" goals context; if iterno > max_iterations then (ParamodulationFailure "No more iterations to spend") else if Unix.gettimeofday () > max_time then @@ -1134,71 +999,88 @@ let given_clause | None -> (* SELECTION *) if passive_is_empty passive then - ParamodulationFailure "No more passive"(*maybe this is a success! *) + if no_more_passive_goals goals then + ParamodulationFailure "No more passive equations/goals" + (*maybe this is a success! *) + else + step goals theorems passive active (iterno+1) else begin (* COLLECTION OF GARBAGED EQUALITIES *) if iterno mod 40 = 0 then begin 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 (fst 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); - prerr_endline (Printf.sprintf "Selected = %s\n" - (Equality.string_of_equality ~env current)) - in (* SIMPLIFICATION OF CURRENT *) + prerr_endline + ("Selected : " ^ + Equality.string_of_equality ~env current); let res = - forward_simplify eq_uri env (Positive, current) active + forward_simplify eq_uri env current active in match res with | None -> step goals theorems passive active (iterno+1) | Some current -> +(* + prerr_endline + ("Selected simpl: " ^ + Equality.string_of_equality ~env current); +*) (* GENERATION OF NEW EQUATIONS *) prerr_endline "infer"; let new' = infer eq_uri env current active in prerr_endline "infer goal"; - let goals = infer_goal_set_with_current env current 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 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 rec simplify new' active passive head = let new' = - forward_simplify_new eq_uri env new' ~passive active + forward_simplify_new eq_uri env new' active in - let active, passive, newa, retained, pruned = - backward_simplify eq_uri env new' ~passive active + let active, newa, retained, pruned = + backward_simplify 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' + | None, None -> active, passive, new', head | Some p, None - | None, Some p -> simplify (new' @ p) active passive - | Some p, Some rp -> simplify (new' @ p @ rp) active passive + | None, Some p -> simplify (new' @ p) active passive head + | Some p, Some rp -> + simplify (new' @ p @ rp) active passive (head @ p) + in + let active, passive, new', head = + simplify new' 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 rc = simplify_goal_set env goals (a,b) in let _ = <:stop> in rc in - let passive = add_to_passive passive new' in + let passive = add_to_passive passive new' head in step goals theorems passive active (iterno+1) end in @@ -1211,12 +1093,12 @@ let rec saturate_equations eq_uri env goal accept_fun passive active = (active, passive) else let current, passive = select env ([goal],[]) passive in - let res = forward_simplify eq_uri env (Positive, current) ~passive active in + let res = forward_simplify eq_uri env current active in match res with | None -> saturate_equations 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 active = @@ -1225,10 +1107,12 @@ let rec saturate_equations eq_uri env goal accept_fun passive active = let al, tbl = active in al @ [current], Indexing.index tbl current 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 new' = forward_simplify_new eq_uri env new' active in + let active, newa, retained, pruned = + backward_simplify eq_uri env new' active in let passive = List.fold_left filter_dependent passive pruned in match newa, retained with @@ -1239,7 +1123,7 @@ let rec saturate_equations eq_uri env goal accept_fun passive active = in let active, passive, new' = simplify new' active passive in let _ = - debug_print + Utils.debug_print (lazy (Printf.sprintf "active:\n%s\n" (String.concat "\n" @@ -1248,7 +1132,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" @@ -1257,176 +1141,10 @@ 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 + let passive = add_to_passive passive new' [] in saturate_equations 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;; @@ -1461,6 +1179,7 @@ let eq_and_ty_of_goal = function ;; let saturate + caso_strano dbd ?(full=false) ?(depth=default_depth) ?(width=default_width) status = let module C = Cic in reset_refs (); @@ -1472,16 +1191,17 @@ let saturate let uri, metasenv, meta_proof, term_to_prove = 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 cleaned_goal = Utils.remove_local_context type_of_goal in + Utils.set_goal_symbols cleaned_goal; + let names = Utils.names_of_context context in + let eq_indexes, equalities, maxm = Inference.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 dbd context (proof, goalno) (maxm+2) + Inference.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 @@ -1489,14 +1209,14 @@ let saturate let equalities = simplify_equalities eq_uri env (equalities@library_equalities) in - debug_print + Utils.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 + let thms = Inference.find_library_theorems dbd env (proof, goalno) lib_eq_uris in + let context_hyp = Inference.find_context_hypotheses env eq_indexes in context_hyp @ thms, [] else let refl_equal = LibraryObjects.eq_refl_URI ~eq:eq_uri in @@ -1506,7 +1226,7 @@ let saturate in let t2 = Unix.gettimeofday () in let _ = - debug_print + Utils.debug_print (lazy (Printf.sprintf "Theorems:\n-------------------------------------\n%s\n" @@ -1517,7 +1237,7 @@ let saturate "Term: %s, type: %s" (CicPp.ppterm t) (CicPp.ppterm ty)) (fst theorems))))); - debug_print + Utils.debug_print (lazy (Printf.sprintf "Time to retrieve theorems: %.9f\n" (t2 -. t1))); in @@ -1547,7 +1267,6 @@ let saturate 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 = @@ -1559,7 +1278,9 @@ let saturate let initial = Equality.add_subst subsumption_subst newproof in Equality.build_goal_proof eq_uri goalproof initial type_of_goal side_effects + context proof_menv in + prerr_endline ("PROOF: " ^ CicPp.pp goal_proof names); let goal_proof = Subst.apply_subst subsumption_subst goal_proof in let metas_still_open_in_proof = Utils.metas_of_term goal_proof in (*prerr_endline (CicPp.pp goal_proof names);*) @@ -1582,8 +1303,8 @@ let saturate (Cic.Meta(i,irl)) ::acc3,Some (Cic.Meta(i,irl))) ([],[],[],None) (List.filter - (fun (i,_,_) -> List.mem i metas_still_open_in_proof) - proof_menv) + (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 @@ -1658,6 +1379,8 @@ prerr_endline ("MENVreal_menv: " ^ CicMetaSubst.ppmetasenv [] real_menv); proof, open_goals ;; +let main _ _ _ _ _ = () ;; + let retrieve_and_print dbd term metasenv ugraph = let module C = Cic in let module T = CicTypeChecker in @@ -1670,16 +1393,16 @@ let retrieve_and_print dbd term metasenv ugraph = 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 eq_indexes, equalities, maxm = Inference.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 dbd context (proof, goal') (maxm+2) in + Inference.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 + Utils.debug_print (lazy (Printf.sprintf "\n\nequalities:\n%s\n" (String.concat "\n" @@ -1690,17 +1413,16 @@ let retrieve_and_print dbd term metasenv ugraph = (* (string_of_equality e) *) ) equalities)))); - debug_print (lazy "RETR: SIMPLYFYING EQUALITIES..."); + Utils.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 active = (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 + let res = forward_simplify eq_uri env e (active, tbl) in match others with | hd::tl -> ( match res with @@ -1717,11 +1439,11 @@ let retrieve_and_print dbd term metasenv ugraph = match equalities with | [] -> [] | hd::tl -> - let others = tl in (* List.map (fun e -> (Positive, e)) tl in *) + let others = tl in (* List.map (fun e -> (Utils.Positive, e)) tl in *) let res = List.rev (simpl (*(Positive,*) hd others []) in - debug_print + Utils.debug_print (lazy (Printf.sprintf "\nequalities AFTER:\n%s\n" (String.concat "\n" @@ -1733,7 +1455,7 @@ let retrieve_and_print dbd term metasenv ugraph = ) res)))); res in - debug_print + Utils.debug_print (lazy (Printf.sprintf "Time to retrieve equalities: %.9f\n" (t2 -. t1))) ;; @@ -1751,16 +1473,16 @@ let main_demod_equalities dbd term metasenv ugraph = 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 eq_indexes, equalities, maxm = Inference.find_equalities context proof in let lib_eq_uris, library_equalities, maxm = - find_library_equalities dbd context (proof, goal') (maxm+2) + Inference.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 + Utils.debug_print (lazy (Printf.sprintf "\n\nTRYING TO INFER EQUALITIES MATCHING: %s\n\n" (CicPp.ppterm ty))); @@ -1778,7 +1500,7 @@ let main_demod_equalities dbd term metasenv ugraph = 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 "\nmetasenv:\n%s\n" (Utils.print_metasenv metasenv); Printf.printf "\nequalities:\n%s\n" (String.concat "\n" (List.map @@ -1801,7 +1523,7 @@ let main_demod_equalities dbd term metasenv ugraph = let passive = match rp with - | (p, _), _ -> + | p, _ -> EqualitySet.elements (List.fold_left addfun EqualitySet.empty p) in let active = @@ -1820,11 +1542,11 @@ let main_demod_equalities dbd term metasenv ugraph = print_newline (); (* with e -> - debug_print (lazy ("EXCEPTION: " ^ (Printexc.to_string e))) + Utils.debug_print (lazy ("EXCEPTION: " ^ (Printexc.to_string e))) *) ;; -let demodulate_tac ~dbd ~pattern ((proof,goal)(*s initialstatus*)) = +let demodulate_tac ~dbd ((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 @@ -1832,7 +1554,7 @@ let demodulate_tac ~dbd ~pattern ((proof,goal)(*s initialstatus*)) = Inference.find_equalities context proof in let lib_eq_uris, library_equalities, maxm = - Inference.find_library_equalities dbd context (proof, goal) (maxm+2) in + 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 @@ -1854,7 +1576,8 @@ let demodulate_tac ~dbd ~pattern ((proof,goal)(*s initialstatus*)) = begin let opengoal = Equality.Exact (Cic.Meta(maxm,irl)) in let proofterm,_ = - Equality.build_goal_proof eq_uri newproof opengoal ty [] + Equality.build_goal_proof + eq_uri newproof opengoal ty [] context metasenv in let extended_metasenv = (maxm,context,newty)::metasenv in let extended_status = @@ -1868,13 +1591,11 @@ let demodulate_tac ~dbd ~pattern ((proof,goal)(*s initialstatus*)) = else (* if newty = ty then *) raise (ProofEngineTypes.Fail (lazy "no progress")) (*else ProofEngineTypes.apply_tactic - (ReductionTactics.simpl_tac ~pattern) - initialstatus*) + (ReductionTactics.simpl_tac + ~pattern:(ProofEngineTypes.conclusion_pattern None)) initialstatus*) ;; -let demodulate_tac ~dbd ~pattern = - ProofEngineTypes.mk_tactic (demodulate_tac ~dbd ~pattern) -;; +let demodulate_tac ~dbd = ProofEngineTypes.mk_tactic (demodulate_tac ~dbd);; let rec find_in_ctx i name = function | [] -> raise (ProofEngineTypes.Fail (lazy ("Hypothesis not found: " ^ name))) @@ -1888,27 +1609,53 @@ let rec position_of i x = function | _ -> i ;; -let superposition_tac ~what ~other ~subterms_only ~demodulate status = +(* 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 what = find_in_ctx 1 what context in - let other = find_in_ctx 1 other context in - let eq_what = List.nth equalities (position_of 0 what eq_index) in - let eq_other = List.nth equalities (position_of 0 other eq_index) in - let index = Indexing.index Indexing.empty eq_other in + let names = Utils.names_of_context context in + let eq_index, equalities, maxm = Inference.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) + 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 + [] + 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 in prerr_endline ("Superposition right:"); prerr_endline ("\n eq: " ^ Equality.string_of_equality eq_what ~env); - prerr_endline ("\n table: " ^ Equality.string_of_equality eq_other ~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): "); @@ -1917,15 +1664,32 @@ let superposition_tac ~what ~other ~subterms_only ~demodulate status = let t = Equality.term_of_equality eq_uri e in prerr_endline (CicPp.pp t names)) eql; - if demodulate then + 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 table = List.fold_left Indexing.index Indexing.empty equalities in + let eql = + if eql = [] then [eq_what] else eql + in + 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 + Indexing.demodulation_equality eq_uri maxm env table e in maxm,eq::acc) (maxm,[]) eql @@ -1946,5 +1710,6 @@ let superposition_tac ~what ~other ~subterms_only ~demodulate status = let get_stats () = <:show> ^ Indexing.get_stats () ^ Inference.get_stats () ^ - Equality.get_stats ();; + Equality.get_stats () +;;