let maxwidth = ref 3;;
type new_proof =
- Equality.goal_proof * Equality.proof * Subst.substitution * Cic.metasenv
+ Equality.goal_proof * Equality.proof * int * Subst.substitution * Cic.metasenv
type result =
| ParamodulationFailure of string
| ParamodulationSuccess of new_proof
passive_table))
| _ ->
symbols_counter := !symbols_ratio;
- let current = EqualitySet.min_elt pos_set in
+ 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
+ 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
in
(** inference of new equalities between current and some in active *)
-let infer env current (active_list, active_table) =
+let infer eq_uri env current (active_list, active_table) =
let (_,c,_) = env in
if Utils.debug_metas then
(ignore(Indexing.check_target c current "infer1");
let active_table = Indexing.index active_table copy_of_current in
let _ = <:start<current contro active>> in
let maxm, res =
- Indexing.superposition_right !maxmeta env active_table current
+ Indexing.superposition_right eq_uri !maxmeta env active_table current
in
let _ = <:stop<current contro active>> in
if Utils.debug_metas then
| [] -> []
| equality::tl ->
let maxm, res =
- Indexing.superposition_right ~subterms_only:true !maxmeta env table equality
+ Indexing.superposition_right
+ ~subterms_only:true eq_uri !maxmeta env table equality
in
maxmeta := maxm;
if Utils.debug_metas then
Equality.mk_tmp_equality(0,(eq_ty,l,r,Utils.Incomparable),metas)in
match Indexing.subsumption env active_table eqtmp with
| None -> false
- | Some (s,eq') ->
-(*
- prerr_endline
- ("\n\n " ^ Equality.string_of_equality ~env eq ^
- "\nis"^(if deep then " CONTEXTUALLY " else " ")^"subsumed by \n " ^
- Equality.string_of_equality ~env eq' ^ "\n\n");
-*)
- true
+ | Some _ -> true
in
let rec aux b (ok_so_far, subsumption_used) t1 t2 =
match t1,t2 with
| t1, t2 when not ok_so_far -> ok_so_far, subsumption_used
| t1, t2 when subsumption_used -> t1 = t2, subsumption_used
-(* VERSIONE ERRATA
- | Cic.Appl (h1::l),Cic.Appl (h2::l') when h1 = h2 ->
- let rc = check_subsumed b t1 t1 in
- if rc then
- true, true
- else if h1 = h2 then
- (try
- List.fold_left2
- (fun (ok_so_far, subsumption_used) t t' ->
- aux true (ok_so_far, subsumption_used) t t')
- (ok_so_far, subsumption_used) l l'
- with Invalid_argument _ -> false,subsumption_used)
- else
- false, subsumption_used
- | _ -> false, subsumption_used *)
| Cic.Appl (h1::l),Cic.Appl (h2::l') ->
let rc = check_subsumed b t1 t2 in
if rc then
fst (aux false (true,false) left right)
;;
-(*
-let check_for_deep env active_table eq =
- match Indexing.subsumption env active_table eq with
- | None -> false
- | Some _ -> true
-;;
-*)
-
-let profiler = HExtlib.profile "check_for_deep";;
-
-let check_for_deep_subsumption env active_table eq =
- profiler.HExtlib.profile (check_for_deep_subsumption env active_table) eq
-;;
-
(* buttare via sign *)
(** simplifies current using active and passive *)
-let forward_simplify env (sign,current) ?passive (active_list, active_table) =
+let forward_simplify
+ eq_uri env (sign,current) ?passive (active_list, active_table)
+=
let _, context, _ = env in
let passive_table =
match passive with
in
let demodulate table current =
let newmeta, newcurrent =
- Indexing.demodulation_equality !maxmeta env table sign current in
+ Indexing.demodulation_equality eq_uri !maxmeta env table sign current in
maxmeta := newmeta;
if Equality.is_identity env newcurrent then
-(* debug_print *)
-(* (lazy *)
-(* (Printf.sprintf "\ncurrent was: %s\nnewcurrent is: %s\n" *)
-(* (string_of_equality current) *)
-(* (string_of_equality newcurrent))); *)
-(* debug_print *)
-(* (lazy *)
-(* (Printf.sprintf "active is: %s" *)
-(* (String.concat "\n" *)
-(* (List.map (fun (_, e) -> (string_of_equality e)) active_list)))); *)
- None
+ None
else
Some newcurrent
in
(* if Indexing.subsumption env active_table c = None then*)
(match Indexing.subsumption env passive_table c with
| None -> res
- | Some (_,c') ->
+ | Some (_,c',_) ->
None
(*prerr_endline "\n\nPESCO DALLE PASSIVE LA PIU' GENERALE\n\n";
Some c'*))
*)
;;
-type fs_time_info_t = {
- mutable build_all: float;
- mutable demodulate: float;
- mutable subsumption: float;
-};;
-
-let fs_time_info = { build_all = 0.; demodulate = 0.; subsumption = 0. };;
-
-
(** simplifies new using active and passive *)
-let forward_simplify_new env new_pos ?passive active =
+let forward_simplify_new eq_uri env new_pos ?passive active =
if Utils.debug_metas then
begin
let m,c,u = env in
in
let demodulate sign table target =
let newmeta, newtarget =
- Indexing.demodulation_equality !maxmeta env table sign target in
+ Indexing.demodulation_equality eq_uri !maxmeta env table sign target
+ in
maxmeta := newmeta;
newtarget
in
List.fold_left
(fun s e ->
if not (Equality.is_identity env e) then
-(* if EqualitySet.mem e s then s *)
- (*else*) EqualitySet.add e s
+ EqualitySet.add e s
else s)
EqualitySet.empty new_pos
in
(fun e -> ((Indexing.subsumption env active_table e = None) &&
(Indexing.subsumption env passive_table e = None)))
in
-(* let t1 = Unix.gettimeofday () in *)
-(* let t2 = Unix.gettimeofday () in *)
-(* fs_time_info.subsumption <- fs_time_info.subsumption +. (t2 -. t1); *)
let is_duplicate =
match passive_table with
| None ->
(** simplifies active usign new *)
-let backward_simplify_active env new_pos new_table min_weight active =
+let backward_simplify_active eq_uri env new_pos new_table min_weight active =
let active_list, active_table = active in
let active_list, newa, pruned =
List.fold_right
if ew < min_weight then
equality::res, newn,pruned
else
- match forward_simplify env (Utils.Positive, equality) (new_pos, new_table) with
+ match
+ forward_simplify
+ eq_uri env (Utils.Positive, equality) (new_pos, new_table)
+ with
| None -> res, newn, id::pruned
| Some e ->
if Equality.compare equality e = 0 then
(** simplifies passive using new *)
-let backward_simplify_passive env new_pos new_table min_weight passive =
+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 ew, _, _, _ , _ = Equality.open_equality equality in
if ew < min_weight then
equality::resl, ress, newn
else
- match forward_simplify env (sign, equality) (new_pos, new_table) with
+ match
+ forward_simplify eq_uri env (sign, equality) (new_pos, new_table)
+ with
| None -> resl, EqualitySet.remove equality ress, newn
| Some e ->
if equality = e then
;;
-let backward_simplify env new' ?passive active =
+let backward_simplify eq_uri env new' ?passive active =
let new_pos, new_table, min_weight = build_table new' in
(*
List.fold_left
in
*)
let active, newa, pruned =
- backward_simplify_active env new_pos new_table min_weight active in
+ backward_simplify_active eq_uri env new_pos new_table min_weight active
+ in
match passive with
| None ->
active, (make_passive []), newa, None, pruned
active, passive, newa, newp *)
;;
-
-let close env new' given =
+let close eq_uri env new' given =
let new_pos, new_table, min_weight =
List.fold_left
(fun (l, t, w) e ->
in
List.fold_left
(fun p c ->
- let pos = infer env c (new_pos,new_table) in
+ let pos = infer eq_uri env c (new_pos,new_table) in
pos@p)
[] given
;;
| _ -> false
;;
-let prova env new' active =
+let prova eq_uri env new' active =
let given = List.filter is_commutative_law (fst active) in
let _ =
debug_print
(List.map
(fun e -> Equality.string_of_equality ~env e)
given)))) in
- close env new' given
+ close eq_uri env new' given
;;
(* returns an estimation of how many equalities in passive can be activated
;;
-let rec simpl env e others others_simpl =
+let rec simpl 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)
Indexing.empty active
in
- let res = forward_simplify env (Positive,e) (active, tbl) in
+ let res = forward_simplify eq_uri env (Positive,e) (active, tbl) in
match others with
| hd::tl -> (
match res with
- | None -> simpl env hd tl others_simpl
- | Some e -> simpl env hd tl (e::others_simpl)
+ | None -> simpl eq_uri env hd tl others_simpl
+ | Some e -> simpl eq_uri env hd tl (e::others_simpl)
)
| [] -> (
match res with
)
;;
-let simplify_equalities env equalities =
+let simplify_equalities eq_uri env equalities =
debug_print
(lazy
(Printf.sprintf "equalities:\n%s\n"
| [] -> []
| hd::tl ->
let res =
- List.rev (simpl env hd tl [])
+ List.rev (simpl eq_uri env hd tl [])
in
debug_print
(lazy
in
Printf.sprintf "%d: %s" d (String.concat "; " gl')) goals))
;;
-
+
let check_if_goal_is_subsumed ((_,ctx,_) as env) table (goalproof,menv,ty) =
-(* let names = names_of_context ctx in*)
-(* Printf.eprintf "check_goal_subsumed: %s\n" (CicPp.pp ty names);*)
+(*
+ let names = names_of_context ctx in
+ Printf.eprintf "check_goal_subsumed: %s\n" (CicPp.pp ty names);
+*)
match ty with
| Cic.Appl[Cic.MutInd(uri,_,_);eq_ty;left;right]
- when UriManager.eq uri (LibraryObjects.eq_URI ()) ->
+ when LibraryObjects.is_eq_URI uri ->
(let goal_equation =
Equality.mk_equality
(0,Equality.Exact (Cic.Implicit None),(eq_ty,left,right,Eq),menv)
in
(* match Indexing.subsumption env table goal_equation with*)
match Indexing.unification env table goal_equation with
- | Some (subst, equality ) ->
+ | Some (subst, equality, swapped ) ->
+ prerr_endline
+ ("GOAL SUBSUMED BY: " ^ Equality.string_of_equality equality);
+ prerr_endline ("SUBST:" ^ Subst.ppsubst subst);
let (_,p,(ty,l,r,_),m,id) = Equality.open_equality equality in
let cicmenv = Subst.apply_subst_metasenv subst (m @ menv) in
- Some (goalproof, p, subst, cicmenv)
- | None -> None)
- | _ -> None
-;;
-
-let counter = ref 0
-
-(** given-clause algorithm with full reduction strategy *)
-let rec given_clause_fullred dbd env goals theorems ~passive active =
- let goals = simplify_goals env goals ~passive active in
- let _,context,_ = env in
- let ok, (goals:
- (Equality.goal_proof * Cic.metasenv * Cic.term) list *
- (Equality.goal_proof * Cic.metasenv * Cic.term) list) = activate_goal
-
- (goals:
- (Equality.goal_proof * Cic.metasenv * Cic.term) list *
- (Equality.goal_proof * Cic.metasenv * Cic.term) list)
- in
-(* let theorems = simplify_theorems env theorems ~passive active in *)
- if ok then
- let names = List.map (HExtlib.map_option (fun (name,_) -> name)) context in
- let _, _, t = List.hd (fst goals) in
- let _ = prerr_endline ("goal activated = " ^ (CicPp.pp t names)) in
-(* let _ = *)
-(* debug_print *)
-(* (lazy *)
-(* (Printf.sprintf "\ngoals = \nactive\n%s\npassive\n%s\n" *)
-(* (print_goals (fst goals)) (print_goals (snd goals)))); *)
-(* let current = List.hd (fst goals) in *)
-(* let p, _, t = List.hd (snd current) in *)
-(* debug_print *)
-(* (lazy *)
-(* (Printf.sprintf "goal activated:\n%s\n%s\n" *)
-(* (CicPp.ppterm t) (string_of_proof p))); *)
-(* in *)
- let ok, proof =
- (* apply_goal_to_theorems dbd env theorems ~passive active goals in *)
- let iseq uri = UriManager.eq uri (LibraryObjects.eq_URI ()) in
- match fst goals with
- | (goalproof,m,Cic.Appl[Cic.MutInd(uri,_,ens);eq_ty;left;right])::_
- when left = right && iseq uri ->
- let reflproof = Equality.Exact (Equality.refl_proof eq_ty left) in
- true, Some (goalproof, reflproof, Subst.empty_subst,m)
- | goal::_ ->
- (match check_if_goal_is_subsumed env (snd active) goal with
- | None -> false,None
- | Some p ->
- prerr_endline "Proof found by subsumption!";
- true, Some p)
- | _ -> false, None
- in
- if ok then
- ( prerr_endline "esco qui";
- (*
- let s = Printf.sprintf "actives:\n%s\n"
- (String.concat "\n"
- ((List.map
- (fun (s, e) -> (string_of_sign s) ^ " " ^
- (string_of_equality ~env e))
- (fst active)))) in
- let sp = Printf.sprintf "passives:\n%s\n"
- (String.concat "\n"
- (List.map
- (string_of_equality ~env)
- (let x,y,_ = passive in (fst x)@(fst y)))) in
- prerr_endline s;
- prerr_endline sp; *)
- match proof with
- | None -> assert false
- | Some p -> ParamodulationSuccess p)
- else
- given_clause_fullred_aux dbd env goals theorems passive active
- else
-(* let ok', theorems = activate_theorem theorems in *)
-(* if ok' then *)
-(* let ok, goals = apply_theorem_to_goals env theorems active goals in *)
-(* if ok then *)
-(* let proof = *)
-(* match (fst goals) with *)
-(* | (_, [proof, _, _])::_ -> Some proof *)
-(* | _ -> assert false *)
-(* in *)
-(* ParamodulationSuccess (proof, env) *)
-(* else *)
-(* given_clause_fullred_aux env goals theorems passive active *)
-(* else *)
- if (passive_is_empty passive) then ParamodulationFailure ""
- else given_clause_fullred_aux dbd env goals theorems passive active
-
-and given_clause_fullred_aux dbd env goals theorems passive active =
- prerr_endline (string_of_int !counter ^
- " MAXMETA: " ^ string_of_int !maxmeta ^
- " #ACTIVES: " ^ string_of_int (size_of_active active) ^
- " #PASSIVES: " ^ string_of_int (size_of_passive passive));
- incr counter;
-(*
- if !counter mod 10 = 0 then
- begin
- let size = HExtlib.estimate_size (passive,active) in
- let sizep = HExtlib.estimate_size (passive) in
- let sizea = HExtlib.estimate_size (active) in
- let (l1,s1),(l2,s2), t = passive in
- let sizetbl = HExtlib.estimate_size t in
- let sizel = HExtlib.estimate_size (l1,l2) in
- let sizes = HExtlib.estimate_size (s1,s2) in
-
- prerr_endline ("SIZE: " ^ string_of_int size);
- prerr_endline ("SIZE P: " ^ string_of_int sizep);
- prerr_endline ("SIZE A: " ^ string_of_int sizea);
- prerr_endline ("SIZE TBL: " ^ string_of_int sizetbl ^
- " SIZE L: " ^ string_of_int sizel ^
- " SIZE S:" ^ string_of_int sizes);
- end;*)
-(*
- if (size_of_active active) mod 50 = 0 then
- (let s = Printf.sprintf "actives:\n%s\n"
- (String.concat "\n"
- ((List.map
- (fun (s, e) -> (string_of_sign s) ^ " " ^
- (string_of_equality ~env e))
- (fst active)))) in
- let sp = Printf.sprintf "passives:\n%s\n"
- (String.concat "\n"
- (List.map
- (string_of_equality ~env)
- (let x,y,_ = passive in (fst x)@(fst y)))) in
- prerr_endline s;
- prerr_endline sp); *)
- let time1 = Unix.gettimeofday () in
- let (_,context,_) = env in
- let selection_estimate = get_selection_estimate () in
- let kept = size_of_passive passive in
- let passive =
- if !time_limit = 0. || !processed_clauses = 0 then
- passive
- else if !elapsed_time > !time_limit then (
- debug_print (lazy (Printf.sprintf "Time limit (%.2f) reached: %.2f\n"
- !time_limit !elapsed_time));
- make_passive []
- ) else if kept > selection_estimate then (
- debug_print
- (lazy (Printf.sprintf ("Too many passive equalities: pruning..." ^^
- "(kept: %d, selection_estimate: %d)\n")
- kept selection_estimate));
- prune_passive selection_estimate active passive
- ) else
- passive
- in
-
- let time2 = Unix.gettimeofday () in
- passive_maintainance_time := !passive_maintainance_time +. (time2 -. time1);
-
- kept_clauses := (size_of_passive passive) + (size_of_active active);
- match passive_is_empty passive with
- | true -> ParamodulationFailure ""
- (* given_clause_fullred dbd env goals theorems passive active *)
- | false ->
- let current, passive = select env goals passive in
- prerr_endline
- ("Selected = " ^ Equality.string_of_equality ~env current);
-(* ^
- (let w,p,(t,l,r,o),m = current in
- " size w: " ^ string_of_int (HExtlib.estimate_size w)^
- " size p: " ^ string_of_int (HExtlib.estimate_size p)^
- " size t: " ^ string_of_int (HExtlib.estimate_size t)^
- " size l: " ^ string_of_int (HExtlib.estimate_size l)^
- " size r: " ^ string_of_int (HExtlib.estimate_size r)^
- " size o: " ^ string_of_int (HExtlib.estimate_size o)^
- " size m: " ^ string_of_int (HExtlib.estimate_size m)^
- " size m-c: " ^ string_of_int
- (HExtlib.estimate_size (List.map (fun (x,_,_) -> x) m)))) *)
- let time1 = Unix.gettimeofday () in
- let res = forward_simplify env (Positive, current) ~passive active in
- let time2 = Unix.gettimeofday () in
- forward_simpl_time := !forward_simpl_time +. (time2 -. time1);
- match res with
- | None ->
- (* weight_age_counter := !weight_age_counter + 1; *)
- given_clause_fullred dbd env goals theorems passive active
- | Some current ->
-(* prerr_endline (Printf.sprintf "selected simpl: %s"
- (Equality.string_of_equality ~env current));*)
- let t1 = Unix.gettimeofday () in
- let new' = infer env current active in
- let _ =
- debug_print
- (lazy
- (Printf.sprintf "new' (senza semplificare):\n%s\n"
- (String.concat "\n"
- (List.map
- (fun e -> "Positive " ^
- (Equality.string_of_equality ~env e)) new'))))
- in
- let t2 = Unix.gettimeofday () in
- infer_time := !infer_time +. (t2 -. t1);
- let active =
- if Equality.is_identity env current then active
+ let p =
+ if swapped then
+ Equality.symmetric eq_ty l id uri m
else
- let al, tbl = active in
- al @ [current], Indexing.index tbl current
- in
- let rec simplify new' active passive =
- let t1 = Unix.gettimeofday () in
- let new' = forward_simplify_new env new'~passive active in
- let t2 = Unix.gettimeofday () in
- forward_simpl_new_time :=
- !forward_simpl_new_time +. (t2 -. t1);
- let t1 = Unix.gettimeofday () in
- let active, passive, newa, retained, pruned =
- backward_simplify env new' ~passive active in
- let passive =
- List.fold_left filter_dependent passive pruned in
- let t2 = Unix.gettimeofday () in
- backward_simpl_time := !backward_simpl_time +. (t2 -. t1);
- match newa, retained with
- | None, None -> active, passive, new'
- | Some p, None
- | None, Some p ->
- if Utils.debug_metas then
- begin
- List.iter
- (fun x->Indexing.check_target context x "simplify1")
- p;
- end;
- simplify (new' @ p) active passive
- | Some p, Some rp ->
- simplify (new' @ p @ rp) active passive
- in
- let active, passive, new' = simplify new' active passive in
- let goals =
- let a,b,_ = build_table new' in
- simplify_goals env goals ~passive (a,b)
- in
-
-(* pessima prova
- let new1 = prova env new' active in
- let new' = (fst new') @ (fst new1), (snd new') @ (snd new1) in
- let _ =
- match new1 with
- | neg, pos ->
- debug_print
- (lazy
- (Printf.sprintf "new1:\n%s\n"
- (String.concat "\n"
- ((List.map
- (fun e -> "Negative " ^
- (string_of_equality ~env e)) neg) @
- (List.map
- (fun e -> "Positive " ^
- (string_of_equality ~env e)) pos)))))
- in
-end prova *)
- let k = size_of_passive passive in
- if k < (kept - 1) then
- processed_clauses := !processed_clauses + (kept - 1 - k);
-
- let _ =
- debug_print
- (lazy
- (Printf.sprintf "active:\n%s\n"
- (String.concat "\n"
- ((List.map
- (fun e -> (Equality.string_of_equality ~env e))
- (fst active))))))
- in
- let _ =
- debug_print
- (lazy
- (Printf.sprintf "new':\n%s\n"
- (String.concat "\n"
- ((List.map
- (fun e -> "Negative " ^
- (Equality.string_of_equality ~env e)) new')))))
+ p
in
- let passive = add_to_passive passive new' in
- given_clause_fullred dbd env goals theorems passive active
+ Some (goalproof, p, id, subst, cicmenv)
+ | None -> None)
+ | _ -> None
;;
-(*
-let profiler0 = HExtlib.profile "P/Saturation.given_clause_fullred"
-
-let given_clause_fullred dbd env goals theorems passive active =
- profiler0.HExtlib.profile
- (given_clause_fullred dbd env goals theorems passive) active
-*)
-
-let iseq uri = UriManager.eq uri (LibraryObjects.eq_URI ());;
-
let check_if_goal_is_identity env = function
| (goalproof,m,Cic.Appl[Cic.MutInd(uri,_,ens);eq_ty;left;right])
- when left = right && iseq uri ->
- let reflproof = Equality.Exact (Equality.refl_proof eq_ty left) in
- Some (goalproof, reflproof,Subst.empty_subst,m)
+ when left = right && LibraryObjects.is_eq_URI uri ->
+ let reflproof = Equality.Exact (Equality.refl_proof uri eq_ty left) in
+ Some (goalproof, reflproof, 0, Subst.empty_subst,m)
+ | (goalproof,m,Cic.Appl[Cic.MutInd(uri,_,ens);eq_ty;left;right])
+ when LibraryObjects.is_eq_URI uri ->
+ (let _,context,_ = env in
+ try
+ let s,m,_ =
+ Inference.unification m m context left right CicUniv.empty_ugraph
+ in
+ let reflproof = Equality.Exact (Equality.refl_proof uri eq_ty left) in
+ let m = Subst.apply_subst_metasenv s m in
+ Some (goalproof, reflproof, 0, s,m)
+ with _ -> None)
| _ -> None
;;
List.fold_left
(fun acc goal ->
match simplify_goal env goal ~passive active with
- | _, g -> if find g acc then acc else g::acc)
+ | 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
;;
let check_if_goals_set_is_solved env active goals =
- let active_goals, passive_goals = goals in
+ let active_goals, passive_goals = goals in
List.fold_left
(fun proof goal ->
match proof with
None active_goals
;;
+let infer_goal_set env active goals =
+ let active_goals, passive_goals = goals in
+ let rec aux = function
+ | [] -> 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'
+ 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)
+ not (List.exists
+ (fun (_,_,t) ->
+ Equality.meta_convertibility t t1)
+ active_goals)
->
let selected = hd in
let passive_goals = tl in
- let new' = Indexing.superposition_left env (snd active) selected in
- selected::active_goals, passive_goals @ new'
+ 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 =
let active_goals, passive_goals = goals in
passive_goals active_goals
;;
+let ids_of_goal g =
+ let p,_,_ = g in
+ let ids = List.map (fun _,_,i,_,_ -> i) p in
+ ids
+;;
+let ids_of_goal_set (ga,gp) =
+ List.flatten (List.map ids_of_goal ga) @
+ List.flatten (List.map ids_of_goal gp)
+;;
let size_of_goal_set_a (l,_) = List.length l;;
let size_of_goal_set_p (_,l) = List.length l;;
(** given-clause algorithm with full reduction strategy: NEW implementation *)
(* here goals is a set of goals in OR *)
let given_clause
- ((_,context,_) as env) goals theorems passive active max_iterations max_time
+ 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
else if Unix.gettimeofday () > max_time then
(ParamodulationFailure "No more time to spend")
else
+(*
let _ = prerr_endline "simpl goal with active" in
- let goals = simplify_goal_set env goals passive active in
+ let _ = <:start<simplify goal set active>> in
+ let goals = simplify_goal_set env goals passive active in
+ let _ = <:stop<simplify goal set active>> 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))
+ in
+ (* PRUNING OF PASSIVE THAT WILL NEVER BE PROCESSED *)
+ let passive =
+ let selection_estimate = iterations_left iterno in
+ let kept = size_of_passive passive in
+ if kept > selection_estimate then
+ begin
+ (*Printf.eprintf "Too many passive equalities: pruning...";
+ prune_passive selection_estimate active*) passive
+ end
+ else
+ passive
+ in
+ kept_clauses := (size_of_passive passive) + (size_of_active active);
+ 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));
-(* assert false;*)
ParamodulationSuccess p
| None ->
- prerr_endline
- (Printf.sprintf "%d #ACTIVES: %d #PASSIVES: %d #GOALSET: %d(%d)\n"
- iterno (size_of_active active) (size_of_passive passive)
- (size_of_goal_set_a goals) (size_of_goal_set_p goals));
- (* PRUNING OF PASSIVE THAT WILL NEVER BE PROCESSED *)
- let passive =
- let selection_estimate = iterations_left iterno in
- let kept = size_of_passive passive in
- if kept > selection_estimate then
- begin
- (*Printf.eprintf "Too many passive equalities: pruning...";
- prune_passive selection_estimate active*) passive
- end
- else
- passive
- in
- kept_clauses := (size_of_passive passive) + (size_of_active active);
(* SELECTION *)
if passive_is_empty passive then
ParamodulationFailure "No more passive"(*maybe this is a success! *)
else
begin
- let goals = infer_goal_set env active goals in
+ (* 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 goal = ids_of_goal_set goals in
+ Equality.collect active passive goal
+ end;
let current, passive = select env goals passive in
- prerr_endline (Printf.sprintf "Selected = %s\n"
- (Equality.string_of_equality ~env current));
+ 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 *)
let res =
- forward_simplify env (Positive, current) ~passive active
+ forward_simplify eq_uri env (Positive, current) active
in
match res with
| None -> step goals theorems passive active (iterno+1)
| Some current ->
(* GENERATION OF NEW EQUATIONS *)
prerr_endline "infer";
- let new' = infer env current active in
+ let new' = infer eq_uri env current active in
prerr_endline "infer goal";
let goals = infer_goal_set_with_current env current goals in
let active =
(* FORWARD AND BACKWARD SIMPLIFICATION *)
prerr_endline "fwd/back simpl";
let rec simplify new' active passive =
- let new' = forward_simplify_new env new' ~passive active in
+ let new' =
+ forward_simplify_new eq_uri env new' ~passive active
+ in
let active, passive, newa, retained, pruned =
- backward_simplify env new' ~passive active
+ backward_simplify eq_uri env new' ~passive active
in
let passive =
List.fold_left filter_dependent passive pruned
prerr_endline "simpl goal with new";
let goals =
let a,b,_ = build_table new' in
- simplify_goal_set env goals passive (a,b)
+ let _ = <:start<simplify_goal_set new>> in
+ let rc = simplify_goal_set env goals passive (a,b) in
+ let _ = <:stop<simplify_goal_set new>> in
+ rc
in
let passive = add_to_passive passive new' in
step goals theorems passive active (iterno+1)
step goals theorems passive active 1
;;
-let rec saturate_equations env goal accept_fun passive active =
+let rec saturate_equations eq_uri env goal accept_fun passive active =
elapsed_time := Unix.gettimeofday () -. !start_time;
if !elapsed_time > !time_limit then
(active, passive)
else
let current, passive = select env ([goal],[]) passive in
- let res = forward_simplify env (Positive, current) ~passive active in
+ let res = forward_simplify eq_uri env (Positive, current) ~passive active in
match res with
| None ->
- saturate_equations env goal accept_fun passive active
+ saturate_equations eq_uri env goal accept_fun passive active
| Some current ->
debug_print (lazy (Printf.sprintf "selected: %s"
(Equality.string_of_equality ~env current)));
- let new' = infer env current active in
+ let new' = infer eq_uri env current active in
let active =
if Equality.is_identity env current then active
else
al @ [current], Indexing.index tbl current
in
let rec simplify new' active passive =
- let new' = forward_simplify_new env new' ~passive active in
+ let new' = forward_simplify_new eq_uri env new' ~passive active in
let active, passive, newa, retained, pruned =
- backward_simplify env new' ~passive active in
+ backward_simplify eq_uri env new' ~passive active in
let passive =
List.fold_left filter_dependent passive pruned in
match newa, retained with
in
let new' = List.filter accept_fun new' in
let passive = add_to_passive passive new' in
- saturate_equations env goal accept_fun passive active
+ saturate_equations eq_uri env goal accept_fun passive active
;;
let main dbd full term metasenv ugraph = ()
Equality.reset ();
;;
+let eq_of_goal = function
+ | Cic.Appl [Cic.MutInd(uri,0,_);_;_;_] when LibraryObjects.is_eq_URI uri ->
+ uri
+ | _ -> raise (ProofEngineTypes.Fail (lazy ("The goal is not an equality ")))
+;;
+
let saturate
dbd ?(full=false) ?(depth=default_depth) ?(width=default_width) status =
let module C = Cic in
reset_refs ();
Indexing.init_index ();
- counter := 0;
maxdepth := depth;
maxwidth := width;
(* CicUnification.unif_ty := false;*)
let proof, goalno = status in
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 ugraph = CicUniv.empty_ugraph in
let env = (metasenv, context, ugraph) in
- let goal = [], metasenv, type_of_goal 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 =
let library_equalities = List.map snd library_equalities in
let t2 = Unix.gettimeofday () in
maxmeta := maxm+2;
- let equalities = simplify_equalities env (equalities@library_equalities) in
+ 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 context_hyp = find_context_hypotheses env eq_indexes in
context_hyp @ thms, []
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 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, [])], []
given_clause_fullred dbd env goals theorems passive active
*)
let goals = make_goal_set goal in
- let max_iterations = 1000 in
- let max_time = Unix.gettimeofday () +. 120. (* minutes *) in
- given_clause env goals theorems passive active max_iterations max_time
+ let max_iterations = 10000 in
+ let max_time = Unix.gettimeofday () +. 600. (* minutes *) in
+ given_clause
+ eq_uri env goals theorems passive active max_iterations max_time
in
let finish = Unix.gettimeofday () in
(res, finish -. start)
| ParamodulationFailure s ->
raise (ProofEngineTypes.Fail (lazy ("NO proof found: " ^ s)))
| ParamodulationSuccess
- (goalproof,newproof,subsumption_subst, proof_menv) ->
+ (goalproof,newproof,subsumption_id,subsumption_subst, proof_menv) ->
prerr_endline "OK, found a proof!";
- prerr_endline (Equality.pp_proof names goalproof newproof);
+ prerr_endline
+ (Equality.pp_proof names goalproof newproof subsumption_subst
+ subsumption_id type_of_goal);
+ prerr_endline (CicMetaSubst.ppmetasenv [] proof_menv);
prerr_endline "ENDOFPROOFS";
(* generation of the CIC proof *)
let side_effects =
~newmetasenv:metasenv ~oldmetasenv:proof_menv)
in
let goal_proof, side_effects_t =
- let initial = newproof in
- Equality.build_goal_proof goalproof initial type_of_goal side_effects
+ 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 (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);*)
+ (* ?? *)
+ 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
| None ->
[i,context,ty], (Cic.Meta(i,[]))::acc2,
(Cic.Meta(i,irl)) ::acc3,Some (Cic.Meta(i,irl)))
- ([],[],[],None) proof_menv
+ ([],[],[],None)
+ (List.filter
+ (fun (i,_,_) -> List.mem i metas_still_open_in_proof)
+ proof_menv)
in
let replace where =
+ (* we need this fake equality since the metas of the hypothesis may be
+ * with a real local context *)
ProofEngineReduction.replace_lifting
- ~equality:(=) ~what ~with_what ~where
+ ~equality:(fun x y ->
+ match x,y with Cic.Meta(i,_),Cic.Meta(j,_) -> i=j | _-> false)
+ ~what ~with_what ~where
in
let goal_proof = replace goal_proof in
(* ok per le meta libere... ma per quelle che c'erano e sono rimaste?
(ProofEngineHelpers.compare_metasenvs
~oldmetasenv:metasenv ~newmetasenv:goal_proof_menv)
in
+prerr_endline ("freemetas: " ^ String.concat "," (List.map string_of_int free_metas) );
(* check/refine/... build the new proof *)
let replaced_goal =
ProofEngineReduction.replace
let final_subst =
(goalno,(context,goal_proof,type_of_goal))::subst_side_effects
in
+prerr_endline ("MENVreal_menv: " ^ CicMetaSubst.ppmetasenv [] real_menv);
let _ =
try
CicTypeChecker.type_of_aux' real_menv context goal_proof
| CicTypeChecker.AssertFailure _
| Invalid_argument "list_fold_left2" as exn ->
prerr_endline "THE PROOF DOES NOT TYPECHECK!";
- prerr_endline (CicPp.pp goal_proof names);
+ prerr_endline (CicPp.pp goal_proof names);
+ prerr_endline "THE PROOF DOES NOT TYPECHECK!";
raise exn
in
let proof, real_metasenv =
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
(fun t (_, e) -> Indexing.index t e)
Indexing.empty active
in
- let res = forward_simplify env (Positive, e) (active, tbl) in
+ let res = forward_simplify eq_uri env (Positive, e) (active, tbl) in
match others with
| hd::tl -> (
match res with
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 dbd context (proof, goal') (maxm+2)
(*try*)
let goal = [], [], goal
in
- let equalities = simplify_equalities env (equalities@library_equalities) 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);
start_time := Unix.gettimeofday ();
if !time_limit < 1. then time_limit := 60.;
let ra, rp =
- saturate_equations env goal (fun e -> true) passive active
+ saturate_equations eq_uri env goal (fun e -> true) passive active
in
let initial =
(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 e)) passive));
+ (List.map
+ (fun e -> CicPp.ppterm (Equality.term_of_equality eq_uri e))
+ passive));
print_newline ();
(*
with e ->
let module I = Inference in
let curi,metasenv,pbo,pty = proof in
let metano,context,ty = CicUtil.lookup_meta goal metasenv in
- let eq_indexes, equalities, maxm = I.find_equalities context proof 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 =
I.find_library_equalities dbd context (proof, goal) (maxm+2) in
if library_equalities = [] then prerr_endline "VUOTA!!!";
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 env (equalities@library_equalities) in
+ let equalities =
+ simplify_equalities eq_uri env (equalities@library_equalities)
+ in
let table =
List.fold_left
(fun tbl eq -> Indexing.index tbl eq)
begin
let opengoal = Equality.Exact (Cic.Meta(maxm,irl)) in
let proofterm,_ =
- Equality.build_goal_proof newproof opengoal ty [] in
+ 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 get_stats () =
- <:show<Saturation.>> ^ Indexing.get_stats () ^ Inference.get_stats ();;
+ <:show<Saturation.>> ^ Indexing.get_stats () ^ Inference.get_stats () ^
+ Equality.get_stats ();;