open AutoTypes;;
open AutoCache;;
-let debug = false;;
+let debug = true;;
let debug_print s =
if debug then prerr_endline (Lazy.force s);;
let default_auto maxm _ _ cache _ _ _ _ = [],cache,maxm ;;
+(* giusto per provare che succede
+let is_unit_equation context metasenv oldnewmeta term =
+ let head, metasenv, args, newmeta =
+ TermUtil.saturate_term oldnewmeta metasenv context term 0
+ in
+ let newmetas =
+ List.filter (fun (i,_,_) -> i >= oldnewmeta) metasenv
+ in
+ Some (args,metasenv,newmetas,head,newmeta) *)
let is_unit_equation context metasenv oldnewmeta term =
let head, metasenv, args, newmeta =
Saturation.make_passive [],
Equality.mk_equality_bag)
+
let init_cache_and_tables
?dbd use_library paramod use_context dont_filter universe (proof, goal)
=
init_cache_and_tables ~dbd flags.use_library true true false universe
(proof'''',newmeta)
in
+ prerr_endline "chiamo given clause";
Saturation.given_clause bag maxmeta (proof'''',newmeta) active passive
max_int max_int flags.timeout
with
| None, _,_,_ ->
raise (ProofEngineTypes.Fail (lazy ("FIXME: propaga le tabelle")))
- | Some (_,proof''''',_), active,passive,_ ->
+ | Some (_,proof''''',_), active,passive,_ ->
+ prerr_endline "torno";
+
proof''''',
ProofEngineHelpers.compare_metasenvs ~oldmetasenv
~newmetasenv:(let _,m,_subst,_,_, _ = proof''''' in m), active, passive
is_propositional context sort
;;
-let assert_proof_is_valid proof metasenv context goalty =
+exception NotConvertible;;
+
+let check_proof_is_valid proof metasenv context goalty =
if debug then
begin
- let ty,u = typeof metasenv context proof CicUniv.oblivion_ugraph in
- let b,_ = CicReduction.are_convertible context ty goalty u in
- if not b then
- begin
- let names =
- List.map (function None -> None | Some (x,_) -> Some x) context
- in
- debug_print (lazy ("PROOF:" ^ CicPp.pp proof names));
- debug_print (lazy ("PROOFTY:" ^ CicPp.pp ty names));
- debug_print (lazy ("GOAL:" ^ CicPp.pp goalty names));
- debug_print (lazy ("MENV:" ^ CicMetaSubst.ppmetasenv [] metasenv));
- end;
- assert b
+ try
+ let ty,u = typeof metasenv context proof CicUniv.oblivion_ugraph in
+ let b,_ = CicReduction.are_convertible context ty goalty u in
+ if not b then raise NotConvertible else b
+ with _ ->
+ let names =
+ List.map (function None -> None | Some (x,_) -> Some x) context
+ in
+ debug_print (lazy ("PROOF:" ^ CicPp.pp proof names));
+ (* debug_print (lazy ("PROOFTY:" ^ CicPp.pp ty names)); *)
+ debug_print (lazy ("GOAL:" ^ CicPp.pp goalty names));
+ debug_print (lazy ("MENV:" ^ CicMetaSubst.ppmetasenv [] metasenv));
+ false
end
- else ()
+ else true
+;;
+
+let assert_proof_is_valid proof metasenv context goalty =
+ assert (check_proof_is_valid proof metasenv context goalty)
;;
let assert_subst_are_disjoint subst subst' =
in
aux [] l
;;
+
let calculate_goal_ty (goalno,_,_) s m =
try
let _,cc,goalty = CicUtil.lookup_meta goalno m in
Some (cc, CicMetaSubst.apply_subst s goalty)
with CicUtil.Meta_not_found i when i = goalno -> None
;;
+
let calculate_closed_goal_ty (goalno,_,_) s =
try
let cc,_,goalty = List.assoc goalno s in
Some (cc, CicMetaSubst.apply_subst s goalty)
with Not_found -> None
;;
+
let pp_status ctx status =
if debug then
let names = Utils.names_of_context ctx in
let metasenv = CicMetaSubst.apply_subst_metasenv subst metasenv in
subst, metasenv
;;
+
let mk_fake_proof metasenv subst (goalno,_,_) goalty context =
None,metasenv,subst ,(lazy (Cic.Meta(goalno,mk_irl context))),goalty, []
;;
let goal_steps, saturation_steps, timeout =
max_int,max_int,flags.timeout
in
+
match
Saturation.given_clause bag maxm status active passive
goal_steps saturation_steps timeout
| (D g)::tl ->
(match calculate_goal_ty g s m with
| None -> aux b tl
- | Some (canonical_ctx, gty) ->
+ | Some (canonical_ctx, gty) ->
let gsize, _ =
Utils.weight_of_term
~consider_metas:false ~count_metas_occurrences:true gty in
let elems = filter_prune_hint elems in
match elems with
| (m, s, size, don, todo, fl)::orlist when !hint <> None ->
+ debug_print (lazy "skip");
(match !hint with
| Some i when condition_for_hint i todo ->
aux tables maxm flags cache orlist
aux tables maxm flags cache elems)
| [] ->
(* complete failure *)
+ debug_print (lazy "give up");
Gaveup (tables, cache, maxm)
| (m, s, _, _, [],_)::orlist ->
(* complete success *)
+ debug_print (lazy "success");
Proved (m, s, orlist, tables, cache, maxm)
| (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 *)
+ debug_print (lazy "skip existential goal");
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 ->
(* partial success, cache g and go on *)
debug_print (lazy ("FAIL: TIMEOUT"));
Gaveup (tables, cache, maxm)
| (m, s, size, don, (D (gno,depth,_ as g))::todo, fl)::orlist as status ->
- (* attack g *)
+ (* attack g *)
+ debug_print (lazy "attack goal");
match calculate_goal_ty g s m with
| None ->
(* closed by side effect *)
debug_print (lazy ("SUCCESS: SIDE EFFECT: " ^ string_of_int gno));
aux tables maxm flags cache ((m,s,size,don,todo, fl)::orlist)
- | Some (canonical_ctx, gty) ->
+ | Some (canonical_ctx, gty) ->
let gsize, _ =
Utils.weight_of_term ~consider_metas:false ~count_metas_occurrences:true gty
in
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));*)
+ debug_print (lazy
+ ("TIME:"^string_of_float(Unix.gettimeofday()-.initial_time)));
let proof,metasenv =
ProofEngineHelpers.subst_meta_and_metasenv_in_proof
proof goal subst metasenv
ProofEngineTypes.mk_tactic (solve_rewrite_tac ~universe ~params)
;;
-(* DEMODULATE *)
+(* Demodulate thorem *)
+let open_type ty bo =
+ let rec open_type_aux context ty k args =
+ match ty with
+ | Cic.Prod (n,s,t) ->
+ let n' =
+ FreshNamesGenerator.mk_fresh_name [] context n ~typ:s ~subst:[] in
+ let entry = match n' with
+ | Cic.Name _ -> Some (n',(Cic.Decl s))
+ | Cic.Anonymous -> None
+ in
+ open_type_aux (entry::context) t (k+1) ((Cic.Rel k)::args)
+ | Cic.LetIn (n,s,sty,t) ->
+ let entry = Some (n,(Cic.Def (s,sty)))
+ in
+ open_type_aux (entry::context) t (k+1) args
+ | _ -> context, ty, args
+ in
+ let context, ty, args = open_type_aux [] ty 1 [] in
+ match args with
+ | [] -> context, ty, bo
+ | _ -> context, ty, Cic.Appl (bo::args)
+;;
+
+let rec close_type bo ty context =
+ match context with
+ | [] -> assert_proof_is_valid bo [] [] ty; (bo,ty)
+ | Some (n,(Cic.Decl s))::tl ->
+ close_type (Cic.Lambda (n,s,bo)) (Cic.Prod (n,s,ty)) tl
+ | Some (n,(Cic.Def (s,sty)))::tl ->
+ close_type (Cic.LetIn (n,s,sty,bo)) (Cic.LetIn (n,s,sty,ty)) tl
+ | _ -> assert false
+;;
+
+let is_subsumed univ context ty =
+ let candidates = Universe.get_candidates univ ty in
+ List.fold_left
+ (fun res cand ->
+ match res with
+ | Some found -> Some found
+ | None ->
+ try
+ let mk_irl = CicMkImplicit.identity_relocation_list_for_metavariable in
+ let metasenv = [(0,context,ty)] in
+ let fake_proof = None,metasenv,[] ,Cic.Meta(0,mk_irl context),ty,[] in
+ let subst,((_,metasenv,_,_,_,_), open_goals),maxmeta =
+ (PrimitiveTactics.apply_with_subst ~subst:[] ~maxmeta:0 ~term:cand) (fake_proof,0)
+ in
+ let prop_goals, other = split_goals_in_prop metasenv subst open_goals in
+ if prop_goals = [] then Some cand else None
+ with
+ | ProofEngineTypes.Fail s -> None
+ | CicUnification.Uncertain s -> None
+ ) None candidates
+;;
+
+let demodulate_theorem ~universe uri =
+ let eq_uri =
+ match LibraryObjects.eq_URI () with
+ | Some (uri) -> uri
+ | None -> raise (ProofEngineTypes.Fail (lazy "equality not declared")) in
+ let obj,_ = CicEnvironment.get_cooked_obj CicUniv.empty_ugraph uri
+ in
+ let context,ty,bo =
+ match obj with
+ | Cic.Constant(n, _, ty ,_, _) -> open_type ty (Cic.Const(uri,[]))
+ | _ -> raise (ProofEngineTypes.Fail (lazy "not a theorem"))
+ in
+ if CicUtil.is_closed ty then
+ raise (ProofEngineTypes.Fail (lazy ("closed term: dangerous reduction")));
+ let initgoal = [], [], ty in
+ (* compute the signature *)
+ let signature =
+ let ty_set = MetadataConstraints.constants_of ty in
+ let hyp_set = MetadataQuery.signature_of_hypothesis context [] in
+ let set = MetadataConstraints.UriManagerSet.union ty_set hyp_set in
+ MetadataQuery.close_with_types set [] context
+ in
+ (* retrieve equations from the universe universe *)
+ let equations =
+ retrieve_equations true signature universe AutoCache.cache_empty context []
+ in
+ debug_print
+ (lazy ("ho trovato equazioni n. "^(string_of_int (List.length equations))));
+ let eqs_and_types =
+ HExtlib.filter_map
+ (fun t ->
+ let ty,_ =
+ CicTypeChecker.type_of_aux' [] context t CicUniv.oblivion_ugraph
+ in
+ (* retrieve_equations could also return flexible terms *)
+ if is_an_equality ty then Some(t,ty)
+ else
+ try
+ let ty' = unfold context ty in
+ if is_an_equality ty' then Some(t,ty') else None
+ with ProofEngineTypes.Fail _ -> None)
+ equations
+ in
+ let bag = Equality.mk_equality_bag () in
+
+ let units, _, newmeta =
+ partition_unit_equalities context [] (CicMkImplicit.new_meta [] []) bag eqs_and_types
+ in
+ let table =
+ List.fold_left
+ (fun tbl eq -> Indexing.index tbl eq)
+ Indexing.empty units
+ in
+ let changed,(newproof,newmetasenv, newty) =
+ Indexing.demod bag
+ ([],context,CicUniv.oblivion_ugraph) table initgoal in
+ if changed then
+ begin
+ let oldproof = Equality.Exact bo in
+ let proofterm,_ =
+ Equality.build_goal_proof (~contextualize:false) (~forward:true) bag
+ eq_uri newproof oldproof ty [] context newmetasenv
+ in
+ if newmetasenv <> [] then
+ raise (ProofEngineTypes.Fail (lazy ("metasenv not empty")))
+ else
+ begin
+ assert_proof_is_valid proofterm newmetasenv context newty;
+ match is_subsumed universe context newty with
+ | Some t -> raise
+ (ProofEngineTypes.Fail (lazy ("subsumed by " ^ CicPp.ppterm t)))
+ | None -> close_type proofterm newty context
+ end
+ end
+ else (* if newty = ty then *)
+ raise (ProofEngineTypes.Fail (lazy "no progress"))
+ (*else ProofEngineTypes.apply_tactic
+ (ReductionTactics.simpl_tac
+ ~pattern:(ProofEngineTypes.conclusion_pattern None)) initialstatus*)
+;;
+
+
+(* NEW DEMODULATE *)
let demodulate_tac ~dbd ~universe ~params:(univ, params) (proof,goal)=
let curi,metasenv,_subst,pbo,pty, attrs = proof in
let metano,context,ty = CicUtil.lookup_meta goal metasenv in
let universe = universe_of_params metasenv context universe univ in
let irl = CicMkImplicit.identity_relocation_list_for_metavariable context in
let initgoal = [], metasenv, ty in
- let eq_uri = eq_of_goal ty in
+ let eq_uri =
+ match LibraryObjects.eq_URI () with
+ | Some (uri) -> uri
+ | None -> raise (ProofEngineTypes.Fail (lazy "equality not declared")) in
+ (* let eq_uri = eq_of_goal ty in *)
let (active,passive,bag), cache, maxm =
init_cache_and_tables
- ~dbd false true true false universe (proof,goal)
+ ~dbd false false true true universe (proof,goal)
in
let equalities = (Saturation.list_of_passive passive) in
(* we demodulate using both actives passives *)
(fun tbl eq -> Indexing.index tbl eq)
(snd active) equalities
in
- let changed,(newproof,newmetasenv, newty) =
- Indexing.demodulation_goal bag
+ let changed,(newproof,newmetasenv, newty) =
+ (* Indexing.demodulation_goal bag *)
+ Indexing.demod bag
(metasenv,context,CicUniv.oblivion_ugraph) table initgoal
in
if changed then
begin
let opengoal = Equality.Exact (Cic.Meta(maxm,irl)) in
let proofterm,_ =
- Equality.build_goal_proof bag
+ Equality.build_goal_proof (~contextualize:false) bag
eq_uri newproof opengoal ty [] context metasenv
in
let extended_metasenv = (maxm,context,newty)::metasenv in
projects / helm.git / commitdiff