let set =
List.fold_left (fun s e -> EqualitySet.add e s) EqualitySet.empty eq_list
in
- (*EqualitySet.elements set*) eq_list, set
+ (*EqualitySet.elements set*) eq_list, set (* see applys.ma *)
;;
let make_empty_active () = [], Indexing.empty ;;
let make_active eq_list =
maxmeta := newmeta;
if Equality.is_identity env newcurrent then None else Some newcurrent
in
- let rec demod current =
+ let demod current =
if Utils.debug_metas then
ignore (Indexing.check_target bag context current "demod0");
let res = demodulate active_table current in
- if Utils.debug_metas then
- ignore ((function None -> () | Some x ->
- ignore (Indexing.check_target bag context x "demod1");()) res);
+ if Utils.debug_metas then
+ ignore ((function None -> () | Some x ->
+ ignore (Indexing.check_target bag context x "demod1");()) res);
res
in
let res = demod current in
let tbl =
List.fold_left
(fun t e ->
- if Equality.is_weak_identity e then t else Indexing.index t e)
+ if Equality.is_identity env e then t else Indexing.index t e)
Indexing.empty active
in
- let res = forward_simplify bag eq_uri env e (active, tbl) in
+ let res =
+ forward_simplify bag eq_uri env e (active, tbl)
+ in
match others with
| hd::tl -> (
match res with
(let _,context,_ = env in
try
let s,m,_ =
- Inference.unification m m context left right CicUniv.empty_ugraph
+ Founif.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
ParamodulationSuccess p
| None ->
*)
+
let active =
let al, tbl = active in
al @ [current], Indexing.index tbl current
let goals =
infer_goal_set_with_current bag env current goals active
in
+
(* FORWARD AND BACKWARD SIMPLIFICATION *)
(* prerr_endline "fwd/back simpl"; *)
let rec simplify new' active passive =
let active, passive, new' =
simplify new' active passive
in
+
(* prerr_endline "simpl goal with new"; *)
let goals =
let a,b,_ = build_table new' in
eq_uri goalproof initial type_of_goal side_effects
context proof_menv
in
-(* prerr_endline ("PROOF: " ^ CicPp.pp goal_proof names); *)
+ (* 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);*)
- (* ?? *)
+ (* 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 =
List.fold_left
(fun (acc1,acc2,acc3,uniq) (i,_,ty) ->
match uniq with
| Some m ->
-(* acc1, (Cic.Meta(i,[]))::acc2, m::acc3, uniq *)
- (i,context,ty)::acc1, (Cic.Meta(i,[]))::acc2, (Cic.Meta(i,irl))::acc3, uniq
+(* acc1, (Cic.Meta(i,[]))::acc2, m::acc3, uniq *)
+ (i,context,ty)::acc1, (Cic.Meta(i,[]))::acc2,
+ (Cic.Meta(i,irl))::acc3, uniq
| None ->
[i,context,ty], (Cic.Meta(i,[]))::acc2,
(Cic.Meta(i,irl)) ::acc3,Some (Cic.Meta(i,irl)))
([],[],[],None)
(List.filter
- (fun (i,_,_) -> List.mem i metas_still_open_in_proof)
+ (fun (i,_,_) ->
+ List.mem i metas_still_open_in_proof
+ (*&& not(List.mem i metas_still_open_in_goal)*))
proof_menv)
in
let replace where =
(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
prerr_endline "THE PROOF DOES NOT TYPECHECK!";
raise exn
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
in
let open_goals =
+ 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"
final_subst, proof, open_goals
;;
-let find_equalities dbd status smart_flag ?auto cache =
+let find_equalities dbd status smart_flag auto cache =
let proof, goalno = status in
let _, metasenv,_,_ = proof in
let _, context, type_of_goal = CicUtil.lookup_meta goalno metasenv in
let env = (metasenv, context, CicUniv.empty_ugraph) in
let bag = Equality.mk_equality_bag () in
let eq_indexes, equalities, maxm, cache =
- Inference.find_equalities 0 bag ?auto context proof cache
+ Equality_retrieval.find_context_equalities 0 bag auto context proof cache
in
prerr_endline ">>>>>>>>>> gained from the context >>>>>>>>>>>>";
List.iter (fun e -> prerr_endline (Equality.string_of_equality e)) equalities;
prerr_endline ">>>>>>>>>>>>>>>>>>>>>>";
let lib_eq_uris, library_equalities, maxm, cache =
- Inference.find_library_equalities bag
- ?auto smart_flag dbd context (proof, goalno) (maxm+2)
+ Equality_retrieval.find_library_equalities bag
+ auto smart_flag dbd context (proof, goalno) (maxm+2)
cache
in
prerr_endline (">>>>>>>>>> gained from the library >>>>>>>>>>>>" ^
bag, equalities, cache, maxm
;;
-let saturate_more bag active maxmeta status smart_flag ?auto cache =
+let close_more bag active maxmeta status smart_flag auto cache =
let proof, goalno = status in
let _, metasenv,_,_ = proof in
let _, context, type_of_goal = CicUtil.lookup_meta goalno metasenv in
let eq_uri = eq_of_goal type_of_goal in
let env = (metasenv, context, CicUniv.empty_ugraph) in
let eq_indexes, equalities, maxm, cache =
- Inference.find_equalities maxmeta bag ?auto context proof cache
+ Equality_retrieval.find_context_equalities maxmeta bag auto context proof cache
in
+ prerr_endline (">>>>>>> gained from a new context saturation >>>>>>>>>" ^
+ string_of_int maxm);
+ List.iter
+ (fun e -> prerr_endline (Equality.string_of_equality ~env e))
+ equalities;
+ prerr_endline ">>>>>>>>>>>>>>>>>>>>>>";
let equalities =
-(*
HExtlib.filter_map
(fun e -> forward_simplify bag eq_uri env e active)
-*)
equalities
in
+ prerr_endline ">>>>>>>>>> after simplify >>>>>>>>>>>>";
+ List.iter
+ (fun e -> prerr_endline (Equality.string_of_equality ~env e)) equalities;
+ prerr_endline (">>>>>>>>>>>>>>>>>>>>>>" ^ string_of_int maxm);
bag, equalities, cache, maxm
let saturate
smart_flag
dbd ?(full=false) ?(depth=default_depth) ?(width=default_width)
- ?(timeout=600.) ?auto status =
+ ?(timeout=600.) auto status =
let module C = Cic in
reset_refs ();
maxdepth := depth;
let env = (metasenv, context, ugraph) in
let goal = [], List.filter (fun (i,_,_)->i<>goalno) metasenv, cleaned_goal in
let bag, equalities, cache, maxm =
- find_equalities dbd status smart_flag ?auto AutoTypes.cache_empty
+ find_equalities dbd status smart_flag auto AutoCache.cache_empty
in
let res, time =
maxmeta := maxm+2;
Utils.set_goal_symbols cleaned_goal; (* DISACTIVATED *)
let goal = [], List.filter (fun (i,_,_)->i<>goalno) metasenv, cleaned_goal in
let env = metasenv,context,CicUniv.empty_ugraph in
+ prerr_endline ">>>>>> ACTIVES >>>>>>>>";
+ List.iter (fun e -> prerr_endline (Equality.string_of_equality ~env e))
+ active_l;
+ prerr_endline ">>>>>>>>>>>>>>";
let goals = make_goal_set goal in
match
given_clause bag eq_uri env goals passive active
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
- let bag = Equality.mk_equality_bag () in
- let eq_indexes, equalities, maxm, cache =
- Inference.find_equalities 0 bag context proof AutoTypes.cache_empty
- in
- let lib_eq_uris, library_equalities, maxm, cache =
- Inference.find_library_equalities bag
- false dbd context (proof, goal) (maxm+2) cache
- 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 bag eq_uri env (equalities@library_equalities)
- in
+ let eq_uri = eq_of_goal ty in
+ let bag, equalities, cache, maxm =
+ find_equalities dbd (proof,goal) false None AutoCache.cache_empty
+ in
let table =
List.fold_left
(fun tbl eq -> Indexing.index tbl eq)
let names = Utils.names_of_context context in
let bag = Equality.mk_equality_bag () in
let eq_index, equalities, maxm,cache =
- Inference.find_equalities 0 bag context proof AutoTypes.cache_empty
+ Equality_retrieval.find_context_equalities 0 bag None context proof AutoCache.cache_empty
in
let eq_what =
let what = find_in_ctx 1 target context in
let get_stats () = ""
(*
- <:show<Saturation.>> ^ Indexing.get_stats () ^ Inference.get_stats () ^
+ <:show<Saturation.>> ^ Indexing.get_stats () ^ Founif.get_stats () ^
Equality.get_stats ()
;;
*)
let eq_uri = eq_of_goal type_of_goal in
let bag = Equality.mk_equality_bag () in
let eq_indexes, equalities, maxm,cache =
- Inference.find_equalities 0 bag context proof AutoTypes.cache_empty in
+ Equality_retrieval.find_context_equalities 0 bag None context proof AutoCache.cache_empty 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, cache =
- Inference.find_library_equalities bag
+ Equality_retrieval.find_library_equalities bag None
false dbd context (proof, goal') (maxm+2) cache
in
let t2 = Unix.gettimeofday () in
let eq_uri = eq_of_goal goal in
let bag = Equality.mk_equality_bag () in
let eq_indexes, equalities, maxm, cache =
- Inference.find_equalities 0 bag context proof AutoTypes.cache_empty in
+ Equality_retrieval.find_context_equalities 0 bag None context proof AutoCache.cache_empty in
let lib_eq_uris, library_equalities, maxm,cache =
- Inference.find_library_equalities bag
+ Equality_retrieval.find_library_equalities bag None
false dbd context (proof, goal') (maxm+2) cache
in
let library_equalities = List.map snd library_equalities in
projects / helm.git / blobdiff