try
let ty' = unfold context ty in
if is_an_equality ty' then Some(t,ty') else None
- with _ -> None) (* catturare l'eccezione giusta di unfold *)
+ with ProofEngineTypes.Fail _ -> None)
equations
in
let bag = Equality.mk_equality_bag () in
| (D (_,_,T))::tl -> aux tl
| _ -> false
and no_progress variant = function
- | [] -> prerr_endline "++++++++++++++++++++++++ no_progress"; true
+ | [] -> (*prerr_endline "++++++++++++++++++++++++ no_progress";*) true
| D ((n,_,P) as g)::tl ->
(match calculate_goal_ty g subst menv with
| None -> no_progress variant tl
| (m, s, _, _, [],_)::orlist ->
(* complete success *)
Proved (m, s, orlist, tables, cache, maxm)
- | (m, s, size, don, (D (_,_,T))::todo, fl)::orlist ->
+ | (m, s, size, don, (D (_,_,T))::todo, fl)::orlist
+ when not flags.AutoTypes.do_types ->
(* skip since not Prop, don't even check if closed by side-effect *)
aux tables maxm flags cache ((m, s, size, don, todo, fl)::orlist)
| (m, s, size, don, (S(g, key, c,minsize) as op)::todo, fl)::orlist ->
(* timeout *)
debug_print (lazy ("FAIL: TIMEOUT"));
Gaveup (tables, cache, maxm)
- | (m, s, size, don, (D (gno,depth,P as g))::todo, fl)::orlist as status ->
+ | (m, s, size, don, (D (gno,depth,_ as g))::todo, fl)::orlist as status ->
(* attack g *)
match calculate_goal_ty g s m with
| None ->
(debug_print (lazy ("FAIL: SIZE: goal: "^string_of_int gsize));
aux tables maxm flags cache orlist)
else if prunable_for_size flags s m todo then
- (prerr_endline ("POTO at depth: "^(string_of_int depth));
+ (debug_print (lazy ("POTO at depth: "^(string_of_int depth)));
aux tables maxm flags cache orlist)
else
(* still to be proved *)
let width = int "width" ((AutoTypes.default_flags()).AutoTypes.maxwidth) in
let size = int "size" ((AutoTypes.default_flags()).AutoTypes.maxsize) in
let gsize = int "gsize" ((AutoTypes.default_flags()).AutoTypes.maxgoalsizefactor) in
+ let do_type = bool "type" false in
let timeout = int "timeout" 0 in
{ AutoTypes.maxdepth =
if use_only_paramod then 2 else depth;
AutoTypes.close_more = close_more;
AutoTypes.dont_cache_failures = false;
AutoTypes.maxgoalsizefactor = gsize;
+ AutoTypes.do_types = do_type;
}
let applyS_tac ~dbd ~term ~params ~universe =
in
match auto_main tables newmeta context flags universe cache [elem] with
| Proved (metasenv,subst,_, tables,cache,_) ->
- prerr_endline
- ("TIME:"^string_of_float(Unix.gettimeofday()-.initial_time));
+ (*prerr_endline
+ ("TIME:"^string_of_float(Unix.gettimeofday()-.initial_time));*)
let proof,metasenv =
ProofEngineHelpers.subst_meta_and_metasenv_in_proof
proof goal subst metasenv
(* we take the whole universe (no signature filtering) *)
init_cache_and_tables false true false true universe (proof,goal)
in
- let initgoal = [], [], ty in
+ let initgoal = [], metasenv, ty in
let table =
let equalities = (Saturation.list_of_passive passive) in
(* we demodulate using both actives passives *)
let curi,metasenv,_subst,pbo,pty, attrs = proof in
let metano,context,ty = CicUtil.lookup_meta goal metasenv in
let irl = CicMkImplicit.identity_relocation_list_for_metavariable context in
- let initgoal = [], [], ty in
+ let initgoal = [], metasenv, ty in
let eq_uri = eq_of_goal ty in
let (active,passive,bag), cache, maxm =
init_cache_and_tables