1 (* Copyright (C) 2002, HELM Team.
3 * This file is part of HELM, an Hypertextual, Electronic
4 * Library of Mathematics, developed at the Computer Science
5 * Department, University of Bologna, Italy.
7 * HELM is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
12 * HELM is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with HELM; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
22 * For details, see the HELM World-Wide-Web page,
23 * http://cs.unibo.it/helm/.
31 if debug then prerr_endline (Lazy.force s);;
33 type auto_params = Cic.term list * (string * string) list
37 (* closing a term w.r.t. its metavariables
38 very naif version: it does not take dependencies properly into account *)
40 let naif_closure ?(prefix_name="xxx_") t metasenv context =
41 let metasenv = ProofEngineHelpers.sort_metasenv metasenv in
42 let n = List.length metasenv in
43 let what = List.map (fun (i,cc,ty) -> Cic.Meta(i,[])) metasenv in
46 (fun (i,acc) (_,cc,ty) -> (i-1,Cic.Rel i::acc))
49 let t = CicSubstitution.lift n t in
51 ProofEngineReduction.replace_lifting
52 ~equality:(fun c t1 t2 ->
54 | Cic.Meta(i,_),Cic.Meta(j,_) -> i = j
56 ~context ~what ~with_what ~where:t
60 (fun (n,t) (_,cc,ty) ->
61 n-1, Cic.Lambda(Cic.Name (prefix_name^string_of_int n),
62 CicSubstitution.lift n ty,t))
68 let lambda_close ?prefix_name t menv ctx =
69 let t = naif_closure ?prefix_name t menv ctx in
71 (fun (t,i) -> function
72 | None -> CicSubstitution.subst (Cic.Implicit None) t,i (* delift *)
73 | Some (name, Cic.Decl ty) -> Cic.Lambda (name, ty, t),i+1
74 | Some (name, Cic.Def (bo, ty)) -> Cic.LetIn (name, bo, ty, t),i+1)
75 (t,List.length menv) ctx
78 (* functions for retrieving theorems *)
80 exception FillingFailure of AutoCache.cache * int
82 let rec unfold context = function
83 | Cic.Prod(name,s,t) ->
84 let t' = unfold ((Some (name,Cic.Decl s))::context) t in
86 | t -> ProofEngineReduction.unfold context t
88 let find_library_theorems dbd proof goal =
89 let univ = MetadataQuery.universe_of_goal ~dbd false proof goal in
90 let terms = List.map CicUtil.term_of_uri univ in
93 (t,fst(CicTypeChecker.type_of_aux' [] [] t CicUniv.oblivion_ugraph)))
96 let find_context_theorems context metasenv =
99 (fun (res,i) ctxentry ->
101 | Some (_,Cic.Decl t) ->
102 (Cic.Rel i, CicSubstitution.lift i t)::res,i+1
103 | Some (_,Cic.Def (_,t)) ->
104 (Cic.Rel i, CicSubstitution.lift i t)::res,i+1
109 let rec is_an_equality = function
110 | Cic.Appl [Cic.MutInd (uri, _, _); _; _; _]
111 when (LibraryObjects.is_eq_URI uri) -> true
112 | Cic.Prod (_, _, t) -> is_an_equality t
116 let partition_equalities =
117 List.partition (fun (_,ty) -> is_an_equality ty)
120 let default_auto maxm _ _ cache _ _ _ _ = [],cache,maxm ;;
123 let is_unit_equation context metasenv oldnewmeta term =
124 let head, metasenv, args, newmeta =
125 TermUtil.saturate_term oldnewmeta metasenv context term 0
127 let propositional_args =
131 let _,_,mt = CicUtil.lookup_meta i metasenv in
133 CicTypeChecker.type_of_aux' metasenv context mt
134 CicUniv.oblivion_ugraph
137 CicReduction.are_convertible ~metasenv context
138 sort (Cic.Sort Cic.Prop) u
140 if b then Some i else None
144 if propositional_args = [] then
146 List.filter (fun (i,_,_) -> i >= oldnewmeta) metasenv
148 Some (args,metasenv,newmetas,head,newmeta)
152 let get_candidates universe cache t =
154 (Universe.get_candidates universe t)@(AutoCache.get_candidates cache t)
157 (lazy ("candidates for " ^ (CicPp.ppterm t) ^ " = " ^
158 (String.concat "\n" (List.map CicPp.ppterm candidates)))) in
159 debug_print debug_msg;
163 let only signature context metasenv t =
166 CicTypeChecker.type_of_aux' metasenv context t CicUniv.oblivion_ugraph
168 let consts = MetadataConstraints.constants_of ty in
169 let b = MetadataConstraints.UriManagerSet.subset consts signature in
172 let ty' = unfold context ty in
173 let consts' = MetadataConstraints.constants_of ty' in
174 MetadataConstraints.UriManagerSet.subset consts' signature
176 | CicTypeChecker.TypeCheckerFailure _ -> assert false
177 | ProofEngineTypes.Fail _ -> false (* unfold may fail *)
180 let not_default_eq_term t =
182 let uri = CicUtil.uri_of_term t in
183 not (LibraryObjects.in_eq_URIs uri)
184 with Invalid_argument _ -> true
186 let retrieve_equations dont_filter signature universe cache context metasenv =
187 match LibraryObjects.eq_URI() with
190 let eq_uri = UriManager.strip_xpointer eq_uri in
191 let fake= Cic.Meta(-1,[]) in
192 let fake_eq = Cic.Appl [Cic.MutInd (eq_uri,0, []);fake;fake;fake] in
193 let candidates = get_candidates universe cache fake_eq in
194 if dont_filter then candidates
196 let candidates = List.filter not_default_eq_term candidates in
197 List.filter (only signature context metasenv) candidates
199 let build_equality bag head args proof newmetas maxmeta =
201 | Cic.Appl [Cic.MutInd (uri, _, _); ty; t1; t2] ->
203 if args = [] then proof else Cic.Appl (proof::args)
205 let o = !Utils.compare_terms t1 t2 in
206 let stat = (ty,t1,t2,o) in
207 (* let w = compute_equality_weight stat in *)
209 let proof = Equality.Exact p in
210 let e = Equality.mk_equality bag (w, proof, stat, newmetas) in
211 (* to clean the local context of metas *)
212 Equality.fix_metas bag maxmeta e
216 let partition_unit_equalities context metasenv newmeta bag equations =
218 (fun (units,other,maxmeta)(t,ty) ->
219 if not (CicUtil.is_meta_closed t && CicUtil.is_meta_closed ty) then
222 ("Skipping " ^ CicMetaSubst.ppterm_in_context ~metasenv [] t context
223 ^ " since it is not meta closed")
225 units,(t,ty)::other,maxmeta
227 match is_unit_equation context metasenv maxmeta ty with
228 | Some (args,metasenv,newmetas,head,newmeta') ->
229 let maxmeta,equality =
230 build_equality bag head args t newmetas newmeta' in
231 equality::units,other,maxmeta
233 units,(t,ty)::other,maxmeta)
234 ([],[],newmeta) equations
237 (Saturation.make_active [],
238 Saturation.make_passive [],
239 Equality.mk_equality_bag)
241 let init_cache_and_tables
242 ?dbd use_library paramod use_context dont_filter universe (proof, goal)
244 (* the local cache in initially empty *)
245 let cache = AutoCache.cache_empty in
246 let _, metasenv, _subst,_, _, _ = proof in
247 let signature = MetadataQuery.signature_of metasenv goal in
248 let newmeta = CicMkImplicit.new_meta metasenv [] in
249 let _,context,_ = CicUtil.lookup_meta goal metasenv in
250 let ct = if use_context then find_context_theorems context metasenv else [] in
252 (lazy ("ho trovato nel contesto " ^ (string_of_int (List.length ct))));
254 match use_library, dbd with
255 | true, Some dbd -> find_library_theorems dbd metasenv goal
259 (lazy ("ho trovato nella libreria " ^ (string_of_int (List.length lt))));
260 let cache = cache_add_list cache context (ct@lt) in
262 retrieve_equations dont_filter signature universe cache context metasenv
265 (lazy ("ho trovato equazioni n. "^(string_of_int (List.length equations))));
270 CicTypeChecker.type_of_aux'
271 metasenv context t CicUniv.oblivion_ugraph
273 (* retrieve_equations could also return flexible terms *)
274 if is_an_equality ty then Some(t,ty)
277 let ty' = unfold context ty in
278 if is_an_equality ty' then Some(t,ty') else None
279 with ProofEngineTypes.Fail _ -> None)
282 let bag = Equality.mk_equality_bag () in
283 let units, other_equalities, newmeta =
284 partition_unit_equalities context metasenv newmeta bag eqs_and_types
286 (* SIMPLIFICATION STEP
288 let env = (metasenv, context, CicUniv.oblivion_ugraph) in
289 let eq_uri = HExtlib.unopt (LibraryObjects.eq_URI()) in
290 Saturation.simplify_equalities bag eq_uri env units
293 let passive = Saturation.make_passive units in
294 let no = List.length units in
295 let active = Saturation.make_active [] in
296 let active,passive,newmeta =
297 if paramod then active,passive,newmeta
299 Saturation.pump_actives
300 context bag newmeta active passive (no+1) infinity
302 (active,passive,bag),cache,newmeta
304 let fill_hypothesis context metasenv oldnewmeta term tables (universe:Universe.universe) cache auto fast =
305 let head, metasenv, args, newmeta =
306 TermUtil.saturate_term oldnewmeta metasenv context term 0
308 let propositional_args =
312 let _,_,mt = CicUtil.lookup_meta i metasenv in
314 CicTypeChecker.type_of_aux' metasenv context mt
315 CicUniv.oblivion_ugraph
318 CicReduction.are_convertible ~metasenv context
319 sort (Cic.Sort Cic.Prop) u
321 if b then Some i else None
325 let results,cache,newmeta =
326 if propositional_args = [] then
327 let newmetas = List.filter (fun (i,_,_) -> i >= oldnewmeta) metasenv in
328 [args,metasenv,newmetas,head,newmeta],cache,newmeta
332 None,metasenv,term,term (* term non e' significativo *)
336 {AutoTypes.default_flags() with
337 AutoTypes.timeout = Unix.gettimeofday() +. 1.0;
338 maxwidth = 2;maxdepth = 2;
339 use_paramod=true;use_only_paramod=false}
341 {AutoTypes.default_flags() with
342 AutoTypes.timeout = Unix.gettimeofday() +. 1.0;
343 maxwidth = 2;maxdepth = 4;
344 use_paramod=true;use_only_paramod=false}
346 match auto newmeta tables universe cache context metasenv propositional_args flags with
347 | [],cache,newmeta -> raise (FillingFailure (cache,newmeta))
348 | substs,cache,newmeta ->
352 CicMetaSubst.apply_subst_metasenv subst metasenv
354 let head = CicMetaSubst.apply_subst subst head in
356 List.filter (fun (i,_,_) ->i >= oldnewmeta) metasenv
358 let args = List.map (CicMetaSubst.apply_subst subst) args in
359 let newm = CicMkImplicit.new_meta metasenv subst in
360 args,metasenv,newmetas,head,max newm newmeta)
361 substs, cache, newmeta
363 results,cache,newmeta
365 let build_equalities auto context metasenv tables universe cache newmeta equations =
367 (fun (facts,cache,newmeta) (t,ty) ->
368 (* in any case we add the equation to the cache *)
369 let cache = AutoCache.cache_add_list cache context [(t,ty)] in
371 let saturated,cache,newmeta =
372 fill_hypothesis context metasenv newmeta ty tables universe cache auto true
374 let (active,passive,bag) = tables in
375 let eqs,bag,newmeta =
377 (fun (acc,bag,newmeta) (args,metasenv,newmetas,head,newmeta') ->
378 let maxmeta,equality =
379 build_equality bag head args t newmetas newmeta'
381 equality::acc,bag,maxmeta)
382 ([],bag,newmeta) saturated
384 (eqs@facts, cache, newmeta)
385 with FillingFailure (cache,newmeta) ->
386 (* if filling hypothesis fails we add the equation to
388 (facts,cache,newmeta)
390 ([],cache,newmeta) equations
392 let close_more tables maxmeta context status auto universe cache =
393 let (active,passive,bag) = tables in
394 let proof, goalno = status in
395 let _, metasenv,_subst,_,_, _ = proof in
396 let signature = MetadataQuery.signature_of metasenv goalno in
398 retrieve_equations false signature universe cache context metasenv
404 CicTypeChecker.type_of_aux' metasenv context t
405 CicUniv.oblivion_ugraph in
406 (* retrieve_equations could also return flexible terms *)
407 if is_an_equality ty then Some(t,ty) else None)
409 let units, cache, maxm =
410 build_equalities auto context metasenv tables universe cache maxmeta eqs_and_types in
411 debug_print (lazy (">>>>>>> gained from a new context saturation >>>>>>>>>" ^
412 string_of_int maxm));
414 (fun e -> debug_print (lazy (Equality.string_of_equality e)))
416 debug_print (lazy ">>>>>>>>>>>>>>>>>>>>>>");
417 let passive = Saturation.add_to_passive units passive in
418 let no = List.length units in
419 debug_print (lazy ("No = " ^ (string_of_int no)));
420 let active,passive,newmeta =
421 Saturation.pump_actives context bag maxm active passive (no+1) infinity
423 (active,passive,bag),cache,newmeta
425 let find_context_equalities
426 maxmeta bag context proof (universe:Universe.universe) cache
428 let module C = Cic in
429 let module S = CicSubstitution in
430 let module T = CicTypeChecker in
431 let _,metasenv,_subst,_,_, _ = proof in
432 let newmeta = max (ProofEngineHelpers.new_meta_of_proof ~proof) maxmeta in
433 (* if use_auto is true, we try to close the hypothesis of equational
434 statements using auto; a naif, and probably wrong approach *)
435 let rec aux cache index newmeta = function
436 | [] -> [], newmeta,cache
437 | (Some (_, C.Decl (term)))::tl ->
440 (Printf.sprintf "Examining: %d (%s)" index (CicPp.ppterm term)));
441 let do_find context term =
443 | C.Prod (name, s, t) when is_an_equality t ->
446 let term = S.lift index term in
447 let saturated,cache,newmeta =
448 fill_hypothesis context metasenv newmeta term
449 empty_tables universe cache default_auto false
453 (fun (acc,newmeta) (args,metasenv,newmetas,head,newmeta') ->
454 let newmeta, equality =
456 bag head args (Cic.Rel index) newmetas (max newmeta newmeta')
458 equality::acc, newmeta + 1)
459 ([],newmeta) saturated
462 with FillingFailure (cache,newmeta) ->
464 | C.Appl [C.MutInd (uri, _, _); ty; t1; t2]
465 when LibraryObjects.is_eq_URI uri ->
466 let term = S.lift index term in
468 build_equality bag term [] (Cic.Rel index) [] newmeta
470 [e], (newmeta+1),cache
471 | _ -> [], newmeta, cache
473 let eqs, newmeta, cache = do_find context term in
474 let rest, newmeta,cache = aux cache (index+1) newmeta tl in
475 List.map (fun x -> index,x) eqs @ rest, newmeta, cache
477 aux cache (index+1) newmeta tl
479 let il, maxm, cache =
480 aux cache 1 newmeta context
482 let indexes, equalities = List.split il in
483 indexes, equalities, maxm, cache
486 (********** PARAMETERS PASSING ***************)
488 let bool params name default =
490 let s = List.assoc name params in
491 if s = "" || s = "1" || s = "true" || s = "yes" || s = "on" then true
492 else if s = "0" || s = "false" || s = "no" || s= "off" then false
494 let msg = "Unrecognized value for parameter "^name^"\n" in
495 let msg = msg^"Accepted values are 1,true,yes,on and 0,false,no,off" in
496 raise (ProofEngineTypes.Fail (lazy msg))
497 with Not_found -> default
500 let string params name default =
501 try List.assoc name params with
502 | Not_found -> default
505 let int params name default =
506 try int_of_string (List.assoc name params) with
507 | Not_found -> default
509 raise (ProofEngineTypes.Fail (lazy (name ^ " must be an integer")))
512 let flags_of_params params ?(for_applyS=false) () =
513 let int = int params in
514 let bool = bool params in
515 let close_more = bool "close_more" false in
516 let use_paramod = bool "use_paramod" true in
517 let use_only_paramod =
518 if for_applyS then true else bool "paramodulation" false in
519 let use_library = bool "library"
520 ((AutoTypes.default_flags()).AutoTypes.use_library) in
521 let depth = int "depth" ((AutoTypes.default_flags()).AutoTypes.maxdepth) in
522 let width = int "width" ((AutoTypes.default_flags()).AutoTypes.maxwidth) in
523 let size = int "size" ((AutoTypes.default_flags()).AutoTypes.maxsize) in
524 let gsize = int "gsize" ((AutoTypes.default_flags()).AutoTypes.maxgoalsizefactor) in
525 let do_type = bool "type" false in
526 let timeout = int "timeout" 0 in
527 { AutoTypes.maxdepth =
528 if use_only_paramod then 2 else depth;
529 AutoTypes.maxwidth = width;
530 AutoTypes.maxsize = size;
533 if for_applyS then Unix.gettimeofday () +. 30.0
537 Unix.gettimeofday() +. (float_of_int timeout);
538 AutoTypes.use_library = use_library;
539 AutoTypes.use_paramod = use_paramod;
540 AutoTypes.use_only_paramod = use_only_paramod;
541 AutoTypes.close_more = close_more;
542 AutoTypes.dont_cache_failures = false;
543 AutoTypes.maxgoalsizefactor = gsize;
544 AutoTypes.do_types = do_type;
547 let universe_of_params metasenv context universe tl =
548 if tl = [] then universe else
552 fst (CicTypeChecker.type_of_aux' metasenv context term
553 CicUniv.oblivion_ugraph))
556 Universe.index_list Universe.empty context (List.combine tl tys)
560 (***************** applyS *******************)
562 let new_metasenv_and_unify_and_t
563 dbd flags universe proof goal ?tables newmeta' metasenv'
564 context term' ty termty goal_arity
566 let (consthead,newmetasenv,arguments,_) =
567 TermUtil.saturate_term newmeta' metasenv' context termty goal_arity in
569 match arguments with [] -> term' | _ -> Cic.Appl (term'::arguments)
571 let proof',oldmetasenv =
572 let (puri,metasenv,_subst,pbo,pty, attrs) = proof in
573 (puri,newmetasenv,_subst,pbo,pty, attrs),metasenv
575 let goal_for_paramod =
576 match LibraryObjects.eq_URI () with
578 Cic.Appl [Cic.MutInd (uri,0,[]); Cic.Sort Cic.Prop; consthead; ty]
579 | None -> raise (ProofEngineTypes.Fail (lazy "No equality defined"))
581 let newmeta = CicMkImplicit.new_meta newmetasenv (*subst*) [] in
582 let metasenv_for_paramod = (newmeta,context,goal_for_paramod)::newmetasenv in
584 let uri,_,_subst,p,ty, attrs = proof' in
585 uri,metasenv_for_paramod,_subst,p,ty, attrs
587 let irl = CicMkImplicit.identity_relocation_list_for_metavariable context in
589 ProofEngineTypes.apply_tactic
590 (EqualityTactics.rewrite_tac ~direction:`RightToLeft
591 ~pattern:(ProofEngineTypes.conclusion_pattern None)
592 (Cic.Meta(newmeta,irl)) [])
595 let goal = match goals with [g] -> g | _ -> assert false in
597 ProofEngineTypes.apply_tactic
598 (PrimitiveTactics.apply_tac term'')
602 let (active, passive,bag), cache, maxmeta =
603 init_cache_and_tables ~dbd flags.use_library true true false universe
606 Saturation.given_clause bag maxmeta (proof'''',newmeta) active passive
607 max_int max_int flags.timeout
610 raise (ProofEngineTypes.Fail (lazy ("FIXME: propaga le tabelle")))
611 | Some (_,proof''''',_), active,passive,_ ->
613 ProofEngineHelpers.compare_metasenvs ~oldmetasenv
614 ~newmetasenv:(let _,m,_subst,_,_, _ = proof''''' in m), active, passive
617 let rec count_prods context ty =
618 match CicReduction.whd context ty with
619 Cic.Prod (n,s,t) -> 1 + count_prods (Some (n,Cic.Decl s)::context) t
623 ~dbd ~term ~subst ~universe ?tables ~params:(univ,params) (proof, goal)
625 let module T = CicTypeChecker in
626 let module R = CicReduction in
627 let module C = Cic in
628 let (_,metasenv,_subst,_,_, _) = proof in
629 let metano,context,ty = CicUtil.lookup_meta goal metasenv in
630 let flags = flags_of_params params ~for_applyS:true () in
631 let universe = universe_of_params metasenv context universe univ in
632 let newmeta = CicMkImplicit.new_meta metasenv subst in
633 let exp_named_subst_diff,newmeta',newmetasenvfragment,term' =
635 C.Var (uri,exp_named_subst) ->
636 let newmeta',newmetasenvfragment,exp_named_subst',exp_named_subst_diff =
637 PrimitiveTactics.generalize_exp_named_subst_with_fresh_metas context newmeta uri
640 exp_named_subst_diff,newmeta',newmetasenvfragment,
641 C.Var (uri,exp_named_subst')
642 | C.Const (uri,exp_named_subst) ->
643 let newmeta',newmetasenvfragment,exp_named_subst',exp_named_subst_diff =
644 PrimitiveTactics.generalize_exp_named_subst_with_fresh_metas context newmeta uri
647 exp_named_subst_diff,newmeta',newmetasenvfragment,
648 C.Const (uri,exp_named_subst')
649 | C.MutInd (uri,tyno,exp_named_subst) ->
650 let newmeta',newmetasenvfragment,exp_named_subst',exp_named_subst_diff =
651 PrimitiveTactics.generalize_exp_named_subst_with_fresh_metas context newmeta uri
654 exp_named_subst_diff,newmeta',newmetasenvfragment,
655 C.MutInd (uri,tyno,exp_named_subst')
656 | C.MutConstruct (uri,tyno,consno,exp_named_subst) ->
657 let newmeta',newmetasenvfragment,exp_named_subst',exp_named_subst_diff =
658 PrimitiveTactics.generalize_exp_named_subst_with_fresh_metas context newmeta uri
661 exp_named_subst_diff,newmeta',newmetasenvfragment,
662 C.MutConstruct (uri,tyno,consno,exp_named_subst')
663 | _ -> [],newmeta,[],term
665 let metasenv' = metasenv@newmetasenvfragment in
667 CicTypeChecker.type_of_aux' metasenv' context term' CicUniv.oblivion_ugraph
669 let termty = CicSubstitution.subst_vars exp_named_subst_diff termty in
670 let goal_arity = count_prods context ty in
671 let proof, gl, active, passive =
672 new_metasenv_and_unify_and_t dbd flags universe proof goal ?tables
673 newmeta' metasenv' context term' ty termty goal_arity
675 proof, gl, active, passive
678 (****************** AUTO ********************)
680 let mk_irl ctx = CicMkImplicit.identity_relocation_list_for_metavariable ctx;;
681 let ugraph = CicUniv.oblivion_ugraph;;
682 let typeof = CicTypeChecker.type_of_aux';;
684 let names = List.map (function None -> None | Some (x,_) -> Some x) ctx in
687 let is_in_prop context subst metasenv ty =
688 let sort,u = typeof ~subst metasenv context ty CicUniv.oblivion_ugraph in
689 fst (CicReduction.are_convertible context sort (Cic.Sort Cic.Prop) u)
692 let assert_proof_is_valid proof metasenv context goalty =
695 let ty,u = typeof metasenv context proof CicUniv.oblivion_ugraph in
696 let b,_ = CicReduction.are_convertible context ty goalty u in
700 List.map (function None -> None | Some (x,_) -> Some x) context
702 debug_print (lazy ("PROOF:" ^ CicPp.pp proof names));
703 debug_print (lazy ("PROOFTY:" ^ CicPp.pp ty names));
704 debug_print (lazy ("GOAL:" ^ CicPp.pp goalty names));
705 debug_print (lazy ("MENV:" ^ CicMetaSubst.ppmetasenv [] metasenv));
712 let assert_subst_are_disjoint subst subst' =
715 (fun (i,_) -> List.for_all (fun (j,_) -> i<>j) subst')
720 let split_goals_in_prop metasenv subst gl =
723 let _,context,ty = CicUtil.lookup_meta g metasenv in
725 let sort,u = typeof ~subst metasenv context ty ugraph in
727 CicReduction.are_convertible
728 ~subst ~metasenv context sort (Cic.Sort Cic.Prop) u in
731 | CicTypeChecker.AssertFailure s
732 | CicTypeChecker.TypeCheckerFailure s ->
734 (lazy ("NON TIPA" ^ ppterm context (CicMetaSubst.apply_subst subst ty)));
737 (* FIXME... they should type! *)
741 let split_goals_with_metas metasenv subst gl =
744 let _,context,ty = CicUtil.lookup_meta g metasenv in
745 let ty = CicMetaSubst.apply_subst subst ty in
746 CicUtil.is_meta_closed ty)
750 let order_new_goals metasenv subst open_goals ppterm =
751 let prop,rest = split_goals_in_prop metasenv subst open_goals in
752 let closed_prop, open_prop = split_goals_with_metas metasenv subst prop in
753 let closed_type, open_type = split_goals_with_metas metasenv subst rest in
755 (List.map (fun x -> x,P) (open_prop @ closed_prop))
757 (List.map (fun x -> x,T) (open_type @ closed_type))
762 let _,_,ty = CicUtil.lookup_meta i metasenv in i,ty,sort) open_goals
764 debug_print (lazy (" OPEN: "^
768 | (i,t,P) -> string_of_int i ^ ":"^ppterm t^ "Prop"
769 | (i,t,T) -> string_of_int i ^ ":"^ppterm t^ "Type")
774 let is_an_equational_goal = function
775 | Cic.Appl [Cic.MutInd(u,_,_);_;_;_] when LibraryObjects.is_eq_URI u -> true
780 let prop = function (_,depth,P) -> depth < 9 | _ -> false;;
783 let calculate_timeout flags =
784 if flags.timeout = 0. then
785 (debug_print (lazy "AUTO WITH NO TIMEOUT");
786 {flags with timeout = infinity})
790 let is_equational_case goalty flags =
791 let ensure_equational t =
792 if is_an_equational_goal t then true
795 let msg="Not an equational goal.\nYou cant use the paramodulation flag"in
796 raise (ProofEngineTypes.Fail (lazy msg))
799 (flags.use_paramod && is_an_equational_goal goalty) ||
800 (flags.use_only_paramod && ensure_equational goalty)
803 let cache_add_success sort cache k v =
804 if sort = P then cache_add_success cache k v else cache_remove_underinspection
809 type menv = Cic.metasenv
810 type subst = Cic.substitution
811 type goal = ProofEngineTypes.goal * int * AutoTypes.sort
812 let candidate_no = ref 0;;
813 type candidate = int * Cic.term
814 type cache = AutoCache.cache
816 Saturation.active_table * Saturation.passive_table * Equality.equality_bag
819 (* the goal (mainly for depth) and key of the goal *)
820 goal * AutoCache.cache_key
822 (* goal has to be proved *)
824 (* goal has to be cached as a success obtained using candidate as the first
826 | S of goal * AutoCache.cache_key * candidate * int
828 (* menv, subst, size, operations done (only S), operations to do, failures to cache if any op fails *)
829 menv * subst * int * op list * op list * fail list
831 (* list of computations that may lead to the solution: all op list will
832 * end with the same (S(g,_)) *)
835 (* menv, subst, alternatives, tables, cache, maxmeta *)
836 | Proved of menv * subst * elem list * tables * cache * int
837 | Gaveup of tables * cache * int
840 (* the status exported to the external observer *)
842 (* context, (goal,candidate) list, and_list, history *)
843 Cic.context * (int * Cic.term * bool * int * (int * Cic.term) list) list *
844 (int * Cic.term * int) list * Cic.term list
847 let rec aux acc = function
848 | (D g)::tl -> aux (acc@[g]) tl
854 List.filter (function (_,_,P) -> true | _ -> false) l
858 let rec aux acc = function
859 | (D g)::tl -> aux (acc@[g]) tl
860 | (S _)::tl -> aux acc tl
865 let calculate_goal_ty (goalno,_,_) s m =
867 let _,cc,goalty = CicUtil.lookup_meta goalno m in
868 (* XXX applicare la subst al contesto? *)
869 Some (cc, CicMetaSubst.apply_subst s goalty)
870 with CicUtil.Meta_not_found i when i = goalno -> None
872 let calculate_closed_goal_ty (goalno,_,_) s =
874 let cc,_,goalty = List.assoc goalno s in
875 (* XXX applicare la subst al contesto? *)
876 Some (cc, CicMetaSubst.apply_subst s goalty)
877 with Not_found -> None
879 let pp_status ctx status =
881 let names = Utils.names_of_context ctx in
884 ProofEngineReduction.replace
885 ~equality:(fun a b -> match b with Cic.Meta _ -> true | _ -> false)
886 ~what:[Cic.Rel 1] ~with_what:[Cic.Implicit None] ~where:x
890 let string_of_do m s (gi,_,_ as g) d =
891 match calculate_goal_ty g s m with
892 | Some (_,gty) -> Printf.sprintf "D(%d, %s, %d)" gi (pp gty) d
893 | None -> Printf.sprintf "D(%d, _, %d)" gi d
895 let string_of_s m su k (ci,ct) gi =
896 Printf.sprintf "S(%d, %s, %s, %d)" gi (pp k) (pp ct) ci
898 let string_of_ol m su l =
902 | D (g,d,s) -> string_of_do m su (g,d,s) d
903 | S ((gi,_,_),k,c,_) -> string_of_s m su k c gi)
906 let string_of_fl m s fl =
908 (List.map (fun ((i,_,_),ty) ->
909 Printf.sprintf "(%d, %s)" i (pp ty)) fl)
911 let rec aux = function
913 | (m,s,_,_,ol,fl)::tl ->
914 Printf.eprintf "< [%s] ;;; [%s]>\n"
915 (string_of_ol m s ol) (string_of_fl m s fl);
918 Printf.eprintf "-------------------------- status -------------------\n";
920 Printf.eprintf "-----------------------------------------------------\n";
923 let auto_status = ref [] ;;
924 let auto_context = ref [];;
925 let in_pause = ref false;;
926 let pause b = in_pause := b;;
927 let cond = Condition.create ();;
928 let mutex = Mutex.create ();;
929 let hint = ref None;;
930 let prune_hint = ref [];;
932 let step _ = Condition.signal cond;;
933 let give_hint n = hint := Some n;;
934 let give_prune_hint hint =
935 prune_hint := hint :: !prune_hint
942 Condition.wait cond mutex;
947 let get_auto_status _ =
948 let status = !auto_status in
949 let and_list,elems,last =
952 | (m,s,_,don,gl,fail)::tl ->
955 (fun (id,d,_ as g) ->
956 match calculate_goal_ty g s m with
957 | Some (_,x) -> Some (id,x,d) | None -> None)
961 (* these are the S goalsin the or list *)
964 (fun (m,s,_,don,gl,fail) ->
966 (function S (g,k,c,_) -> Some (g,k,c) | _ -> None)
970 (* this function eats id from a list l::[id,x] returning x, l *)
971 let eat_tail_if_eq id l =
972 let rec aux (s, l) = function
974 | ((id1,_,_),k1,c)::tl when id = id1 ->
976 | None -> aux (Some c,l) tl
977 | Some _ -> assert false)
978 | ((id1,_,_),k1,c as e)::tl -> aux (s, e::l) tl
980 let c, l = aux (None, []) l in
983 let eat_in_parallel id l =
984 let rec aux (b,eaten, new_l as acc) l =
988 match eat_tail_if_eq id l with
989 | None, l -> aux (b@[false], eaten, new_l@[l]) tl
990 | Some t,l -> aux (b@[true],eaten@[t], new_l@[l]) tl
994 let rec eat_all rows l =
998 match List.rev elem with
999 | ((to_eat,depth,_),k,_)::next_lunch ->
1000 let b, eaten, l = eat_in_parallel to_eat l in
1001 let eaten = HExtlib.list_uniq eaten in
1002 let eaten = List.rev eaten in
1003 let b = true (* List.hd (List.rev b) *) in
1004 let rows = rows @ [to_eat,k,b,depth,eaten] in
1006 | [] -> eat_all rows or_list
1008 eat_all [] (List.rev orlist)
1012 (function (S (_,_,(_,c),_)) -> Some c | _ -> None)
1015 (* let rows = List.filter (fun (_,l) -> l <> []) rows in *)
1016 and_list, rows, history
1018 !auto_context, elems, and_list, last
1021 (* Works if there is no dependency over proofs *)
1022 let is_a_green_cut goalty =
1023 CicUtil.is_meta_closed goalty
1025 let rec first_s = function
1026 | (D _)::tl -> first_s tl
1027 | (S (g,k,c,s))::tl -> Some ((g,k,c,s),tl)
1030 let list_union l1 l2 =
1031 (* TODO ottimizzare compare *)
1032 HExtlib.list_uniq (List.sort compare (l1 @ l1))
1034 let eat_head todo id fl orlist =
1035 let rec aux acc = function
1037 | (m, s, _, _, todo1, fl1)::tl as orlist ->
1038 let rec aux1 todo1 =
1039 match first_s todo1 with
1040 | None -> orlist, acc
1041 | Some (((gno,_,_),_,_,_), todo11) ->
1042 (* TODO confronto tra todo da ottimizzare *)
1043 if gno = id && todo11 = todo then
1044 aux (list_union fl1 acc) tl
1052 let close_proof p ty menv context =
1054 List.map fst (CicUtil.metas_of_term p @ CicUtil.metas_of_term ty)
1056 let menv = List.filter (fun (i,_,_) -> List.exists ((=)i) metas) menv in
1057 naif_closure p menv context
1059 (* XXX capire bene quando aggiungere alla cache *)
1060 let add_to_cache_and_del_from_orlist_if_green_cut
1061 g s m cache key todo orlist fl ctx size minsize
1063 let cache = cache_remove_underinspection cache key in
1064 (* prima per fare la irl usavamo il contesto vero e proprio e non quello
1066 match calculate_closed_goal_ty g s with
1067 | None -> assert false
1068 | Some (canonical_ctx , gty) ->
1069 let goalno,depth,sort = g in
1070 let irl = mk_irl canonical_ctx in
1071 let goal = Cic.Meta(goalno, irl) in
1072 let proof = CicMetaSubst.apply_subst s goal in
1073 let green_proof, closed_proof =
1074 let b = is_a_green_cut proof in
1076 b, (* close_proof proof gty m ctx *) proof
1080 debug_print (lazy ("TENTATIVE CACHE: " ^ CicPp.ppterm key));
1081 if is_a_green_cut key then
1082 (* if the initia goal was closed, we cut alternatives *)
1083 let _ = debug_print (lazy ("MANGIO: " ^ string_of_int goalno)) in
1084 let orlist, fl = eat_head todo goalno fl orlist in
1086 if size < minsize then
1087 (debug_print (lazy ("NO CACHE: 2 (size <= minsize)"));cache)
1089 (* if the proof is closed we cache it *)
1090 if green_proof then cache_add_success cache key proof
1091 else (* cache_add_success cache key closed_proof *)
1092 (debug_print (lazy ("NO CACHE: (no gree proof)"));cache)
1094 cache, orlist, fl, true
1097 debug_print (lazy ("TENTATIVE CACHE: " ^ CicPp.ppterm gty));
1098 if size < minsize then
1099 (debug_print (lazy ("NO CACHE: (size <= minsize)")); cache) else
1100 (* if the substituted goal and the proof are closed we cache it *)
1101 if is_a_green_cut gty then
1102 if green_proof then cache_add_success cache gty proof
1103 else (* cache_add_success cache gty closed_proof *)
1104 (debug_print (lazy ("NO CACHE: (no green proof (gty))"));cache)
1108 CicTypeChecker.type_of_aux' ~subst:s
1109 m ctx closed_proof CicUniv.oblivion_ugraph
1111 if is_a_green_cut ty then
1112 cache_add_success cache ty closed_proof
1115 | CicTypeChecker.TypeCheckerFailure _ ->*)
1116 (debug_print (lazy ("NO CACHE: (no green gty )"));cache)
1118 cache, orlist, fl, false
1120 let close_failures (fl : fail list) (cache : cache) =
1122 (fun cache ((gno,depth,_),gty) ->
1123 debug_print (lazy ("FAIL: INDUCED: " ^ string_of_int gno));
1124 cache_add_failure cache gty depth)
1127 let put_in_subst subst metasenv (goalno,_,_) canonical_ctx t ty =
1128 let entry = goalno, (canonical_ctx, t,ty) in
1129 assert_subst_are_disjoint subst [entry];
1130 let subst = entry :: subst in
1131 let metasenv = CicMetaSubst.apply_subst_metasenv subst metasenv in
1134 let mk_fake_proof metasenv subst (goalno,_,_) goalty context =
1135 None,metasenv,subst ,Cic.Meta(goalno,mk_irl context),goalty, []
1138 tables maxm cache depth fake_proof goalno goalty subst context
1141 let active,passive,bag = tables in
1142 let ppterm = ppterm context in
1143 let status = (fake_proof,goalno) in
1144 if flags.use_only_paramod then
1146 debug_print (lazy ("PARAMODULATION SU: " ^
1147 string_of_int goalno ^ " " ^ ppterm goalty ));
1148 let goal_steps, saturation_steps, timeout =
1149 max_int,max_int,flags.timeout
1152 Saturation.given_clause bag maxm status active passive
1153 goal_steps saturation_steps timeout
1155 | None, active, passive, maxmeta ->
1156 [], (active,passive,bag), cache, maxmeta, flags
1157 | Some(subst',(_,metasenv,_subst,proof,_, _),open_goals),active,
1159 assert_subst_are_disjoint subst subst';
1160 let subst = subst@subst' in
1162 order_new_goals metasenv subst open_goals ppterm
1165 List.map (fun (x,sort) -> x,depth-1,sort) open_goals
1168 [(!candidate_no,proof),metasenv,subst,open_goals],
1169 (active,passive,bag),
1170 cache, maxmeta, flags
1176 ("SUBSUMPTION SU: " ^ string_of_int goalno ^ " " ^ ppterm goalty));
1178 Saturation.all_subsumed bag maxm status active passive
1180 assert (maxmeta >= maxm);
1183 (fun (subst',(_,metasenv,_subst,proof,_, _),open_goals) ->
1184 assert_subst_are_disjoint subst subst';
1185 let subst = subst@subst' in
1187 order_new_goals metasenv subst open_goals ppterm
1190 List.map (fun (x,sort) -> x,depth-1,sort) open_goals
1193 (!candidate_no,proof),metasenv,subst,open_goals)
1196 res', (active,passive,bag), cache, maxmeta, flags
1201 goalty tables maxm subst fake_proof goalno depth context cand
1203 let ppterm = ppterm context in
1205 let subst,((_,metasenv,_,_,_,_), open_goals),maxmeta =
1206 (PrimitiveTactics.apply_with_subst ~subst ~maxmeta:maxm ~term:cand)
1209 debug_print (lazy (" OK: " ^ ppterm cand));
1210 let metasenv = CicRefine.pack_coercion_metasenv metasenv in
1211 let open_goals = order_new_goals metasenv subst open_goals ppterm in
1212 let open_goals = List.map (fun (x,sort) -> x,depth-1,sort) open_goals in
1214 Some ((!candidate_no,cand),metasenv,subst,open_goals), tables , maxmeta
1216 | ProofEngineTypes.Fail s -> None,tables, maxm
1217 | CicUnification.Uncertain s -> None,tables, maxm
1220 let sort_new_elems =
1221 List.sort (fun (_,_,_,l1) (_,_,_,l2) ->
1222 List.length (prop_only l1) - List.length (prop_only l2))
1225 let applicative_case
1226 tables maxm depth subst fake_proof goalno goalty metasenv context universe
1229 let candidates = get_candidates universe cache goalty in
1230 let tables, elems, maxm =
1232 (fun (tables,elems,maxm) cand ->
1234 try_candidate goalty
1235 tables maxm subst fake_proof goalno depth context cand
1237 | None, tables,maxm -> tables,elems, maxm
1238 | Some x, tables, maxm -> tables,x::elems, maxm)
1239 (tables,[],maxm) candidates
1241 let elems = sort_new_elems elems in
1242 elems, tables, cache, maxm
1245 let equational_and_applicative_case
1246 universe flags m s g gty tables cache maxm context
1248 let goalno, depth, sort = g in
1249 let fake_proof = mk_fake_proof m s g gty context in
1250 if is_equational_case gty flags then
1251 let elems,tables,cache,maxm1, flags =
1252 equational_case tables maxm cache
1253 depth fake_proof goalno gty s context flags
1256 let more_elems, tables, cache, maxm1 =
1257 if flags.use_only_paramod then
1258 [],tables, cache, maxm
1261 tables maxm depth s fake_proof goalno
1262 gty m context universe cache
1265 elems@more_elems, tables, cache, maxm, flags
1267 let elems, tables, cache, maxm =
1268 applicative_case tables maxm depth s fake_proof goalno
1269 gty m context universe cache
1271 elems, tables, cache, maxm, flags
1273 let rec condition_for_hint i = function
1275 | S (_,_,(j,_),_):: tl -> j <> i (* && condition_for_hint i tl *)
1276 | _::tl -> condition_for_hint i tl
1278 let remove_s_from_fl (id,_,_) (fl : fail list) =
1279 let rec aux = function
1281 | ((id1,_,_),_)::tl when id = id1 -> tl
1282 | hd::tl -> hd :: aux tl
1287 let prunable_for_size flags s m todo =
1288 let rec aux b = function
1289 | (S _)::tl -> aux b tl
1290 | (D (_,_,T))::tl -> aux b tl
1292 (match calculate_goal_ty g s m with
1294 | Some (canonical_ctx, gty) ->
1296 Utils.weight_of_term
1297 ~consider_metas:false ~count_metas_occurrences:true gty in
1298 let newb = b || gsize > flags.maxgoalsizefactor in
1305 let prunable ty todo =
1306 let rec aux b = function
1307 | (S(_,k,_,_))::tl -> aux (b || Equality.meta_convertibility k ty) tl
1308 | (D (_,_,T))::tl -> aux b tl
1316 let prunable menv subst ty todo =
1317 let rec aux = function
1318 | (S(_,k,_,_))::tl ->
1319 (match Equality.meta_convertibility_subst k ty menv with
1322 no_progress variant tl (* || aux tl*))
1323 | (D (_,_,T))::tl -> aux tl
1325 and no_progress variant = function
1326 | [] -> (*prerr_endline "++++++++++++++++++++++++ no_progress";*) true
1327 | D ((n,_,P) as g)::tl ->
1328 (match calculate_goal_ty g subst menv with
1329 | None -> no_progress variant tl
1331 (match calculate_goal_ty g variant menv with
1332 | None -> assert false
1335 no_progress variant tl
1337 | _::tl -> no_progress variant tl
1342 let condition_for_prune_hint prune (m, s, size, don, todo, fl) =
1344 HExtlib.filter_map (function S (_,_,(c,_),_) -> Some c | _ -> None) todo
1346 List.for_all (fun i -> List.for_all (fun j -> i<>j) prune) s
1348 let filter_prune_hint l =
1349 let prune = !prune_hint in
1350 prune_hint := []; (* possible race... *)
1351 if prune = [] then l
1352 else List.filter (condition_for_prune_hint prune) l
1354 let auto_main tables maxm context flags universe cache elems =
1355 auto_context := context;
1356 let rec aux tables maxm flags cache (elems : status) =
1357 (* pp_status context elems; *)
1358 (* DEBUGGING CODE: uncomment these two lines to stop execution at each iteration
1359 auto_status := elems;
1362 let elems = filter_prune_hint elems in
1364 | (m, s, size, don, todo, fl)::orlist when !hint <> None ->
1366 | Some i when condition_for_hint i todo ->
1367 aux tables maxm flags cache orlist
1370 aux tables maxm flags cache elems)
1372 (* complete failure *)
1373 Gaveup (tables, cache, maxm)
1374 | (m, s, _, _, [],_)::orlist ->
1375 (* complete success *)
1376 Proved (m, s, orlist, tables, cache, maxm)
1377 | (m, s, size, don, (D (_,_,T))::todo, fl)::orlist
1378 when not flags.AutoTypes.do_types ->
1379 (* skip since not Prop, don't even check if closed by side-effect *)
1380 aux tables maxm flags cache ((m, s, size, don, todo, fl)::orlist)
1381 | (m, s, size, don, (S(g, key, c,minsize) as op)::todo, fl)::orlist ->
1382 (* partial success, cache g and go on *)
1383 let cache, orlist, fl, sibling_pruned =
1384 add_to_cache_and_del_from_orlist_if_green_cut
1385 g s m cache key todo orlist fl context size minsize
1387 debug_print (lazy (AutoCache.cache_print context cache));
1388 let fl = remove_s_from_fl g fl in
1389 let don = if sibling_pruned then don else op::don in
1390 aux tables maxm flags cache ((m, s, size, don, todo, fl)::orlist)
1391 | (m, s, size, don, todo, fl)::orlist
1392 when List.length(prop_only (d_goals todo)) > flags.maxwidth ->
1393 debug_print (lazy ("FAIL: WIDTH"));
1394 (* too many goals in and generated by last th *)
1395 let cache = close_failures fl cache in
1396 aux tables maxm flags cache orlist
1397 | (m, s, size, don, todo, fl)::orlist when size > flags.maxsize ->
1399 (lazy ("FAIL: SIZE: "^string_of_int size ^
1400 " > " ^ string_of_int flags.maxsize ));
1401 (* we already have a too large proof term *)
1402 let cache = close_failures fl cache in
1403 aux tables maxm flags cache orlist
1404 | _ when Unix.gettimeofday () > flags.timeout ->
1406 debug_print (lazy ("FAIL: TIMEOUT"));
1407 Gaveup (tables, cache, maxm)
1408 | (m, s, size, don, (D (gno,depth,_ as g))::todo, fl)::orlist as status ->
1410 match calculate_goal_ty g s m with
1412 (* closed by side effect *)
1413 debug_print (lazy ("SUCCESS: SIDE EFFECT: " ^ string_of_int gno));
1414 aux tables maxm flags cache ((m,s,size,don,todo, fl)::orlist)
1415 | Some (canonical_ctx, gty) ->
1417 Utils.weight_of_term ~consider_metas:false ~count_metas_occurrences:true gty
1419 if gsize > flags.maxgoalsizefactor then
1420 (debug_print (lazy ("FAIL: SIZE: goal: "^string_of_int gsize));
1421 aux tables maxm flags cache orlist)
1422 else if prunable_for_size flags s m todo then
1423 (debug_print (lazy ("POTO at depth: "^(string_of_int depth)));
1424 aux tables maxm flags cache orlist)
1426 (* still to be proved *)
1427 (debug_print (lazy ("EXAMINE: "^CicPp.ppterm gty));
1428 match cache_examine cache gty with
1429 | Failed_in d when d >= depth ->
1431 debug_print (lazy ("FAIL: DEPTH (cache): "^string_of_int gno));
1432 let cache = close_failures fl cache in
1433 aux tables maxm flags cache orlist
1434 | UnderInspection ->
1436 debug_print (lazy ("FAIL: LOOP: " ^ string_of_int gno));
1437 let cache = close_failures fl cache in
1438 aux tables maxm flags cache orlist
1440 debug_print (lazy ("SUCCESS: CACHE HIT: " ^ string_of_int gno));
1441 let s, m = put_in_subst s m g canonical_ctx t gty in
1442 aux tables maxm flags cache ((m, s, size, don,todo, fl)::orlist)
1444 | Failed_in _ when depth > 0 ->
1445 ( (* more depth or is the first time we see the goal *)
1446 if prunable m s gty todo then
1448 "FAIL: LOOP: one father is equal"));
1449 aux tables maxm flags cache orlist)
1451 let cache = cache_add_underinspection cache gty depth in
1452 auto_status := status;
1455 (lazy ("INSPECTING: " ^
1456 string_of_int gno ^ "("^ string_of_int size ^ "): "^
1458 (* elems are possible computations for proving gty *)
1459 let elems, tables, cache, maxm, flags =
1460 equational_and_applicative_case
1461 universe flags m s g gty tables cache maxm context
1464 (* this goal has failed *)
1465 let cache = close_failures ((g,gty)::fl) cache in
1466 aux tables maxm flags cache orlist
1468 (* elems = (cand,m,s,gl) *)
1469 let size_gl l = List.length
1470 (List.filter (function (_,_,P) -> true | _ -> false) l)
1473 let inj_gl gl = List.map (fun g -> D g) gl in
1474 let rec map = function
1475 | [] -> assert false
1476 | (cand,m,s,gl)::[] ->
1477 (* in the last one we add the failure *)
1479 inj_gl gl @ (S(g,gty,cand,size+1))::todo
1481 (* we are the last in OR, we fail on g and
1482 * also on all failures implied by g *)
1483 (m,s, size + size_gl gl, don, todo, (g,gty)::fl)
1485 | (cand,m,s,gl)::tl ->
1486 (* we add the S step after gl and before todo *)
1488 inj_gl gl @ (S(g,gty,cand,size+1))::todo
1490 (* since we are not the last in OR, we do not
1492 (m,s, size + size_gl gl, don, todo, []) :: map tl
1496 aux tables maxm flags cache elems)
1499 debug_print (lazy ("FAIL: DEPTH: " ^ string_of_int gno));
1500 let cache = close_failures fl cache in
1501 aux tables maxm flags cache orlist)
1503 (aux tables maxm flags cache elems : auto_result)
1508 auto_all_solutions maxm tables universe cache context metasenv gl flags
1510 let goals = order_new_goals metasenv [] gl CicPp.ppterm in
1513 (fun (x,s) -> D (x,flags.maxdepth,s)) goals
1515 let elems = [metasenv,[],1,[],goals,[]] in
1516 let rec aux tables maxm solutions cache elems flags =
1517 match auto_main tables maxm context flags universe cache elems with
1518 | Gaveup (tables,cache,maxm) ->
1519 solutions,cache,maxm
1520 | Proved (metasenv,subst,others,tables,cache,maxm) ->
1521 if Unix.gettimeofday () > flags.timeout then
1522 ((subst,metasenv)::solutions), cache, maxm
1524 aux tables maxm ((subst,metasenv)::solutions) cache others flags
1526 let rc = aux tables maxm [] cache elems flags in
1528 | [],cache,maxm -> [],cache,maxm
1529 | solutions,cache,maxm ->
1532 (fun (subst,newmetasenv) ->
1534 ProofEngineHelpers.compare_metasenvs ~oldmetasenv:metasenv ~newmetasenv
1536 if opened = [] then Some subst else None)
1539 solutions,cache,maxm
1542 (* }}} ****************** AUTO ***************)
1544 let auto flags metasenv tables universe cache context metasenv gl =
1545 let initial_time = Unix.gettimeofday() in
1546 let goals = order_new_goals metasenv [] gl CicPp.ppterm in
1547 let goals = List.map (fun (x,s) -> D(x,flags.maxdepth,s)) goals in
1548 let elems = [metasenv,[],1,[],goals,[]] in
1549 match auto_main tables 0 context flags universe cache elems with
1550 | Proved (metasenv,subst,_, tables,cache,_) ->
1552 ("TIME:"^string_of_float(Unix.gettimeofday()-.initial_time)));
1553 Some (subst,metasenv), cache
1554 | Gaveup (tables,cache,maxm) ->
1556 ("TIME:"^string_of_float(Unix.gettimeofday()-.initial_time)));
1560 let applyS_tac ~dbd ~term ~params ~universe =
1561 ProofEngineTypes.mk_tactic
1565 apply_smart ~dbd ~term ~subst:[] ~params ~universe status
1569 | CicUnification.UnificationFailure msg
1570 | CicTypeChecker.TypeCheckerFailure msg ->
1571 raise (ProofEngineTypes.Fail msg))
1573 let auto_tac ~(dbd:HSql.dbd) ~params:(univ,params) ~universe (proof, goal) =
1574 let _,metasenv,_subst,_,_, _ = proof in
1575 let _,context,goalty = CicUtil.lookup_meta goal metasenv in
1576 let universe = universe_of_params metasenv context universe univ in
1577 let flags = flags_of_params params () in
1578 let use_library = flags.use_library in
1579 let tables,cache,newmeta =
1580 init_cache_and_tables ~dbd use_library flags.use_only_paramod true
1581 false universe (proof, goal) in
1582 let tables,cache,newmeta =
1583 if flags.close_more then
1585 tables newmeta context (proof, goal)
1586 auto_all_solutions universe cache
1587 else tables,cache,newmeta in
1588 let initial_time = Unix.gettimeofday() in
1589 let (_,oldmetasenv,_subst,_,_, _) = proof in
1592 metasenv,[],1,[],[D (goal,flags.maxdepth,P)],[]
1594 match auto_main tables newmeta context flags universe cache [elem] with
1595 | Proved (metasenv,subst,_, tables,cache,_) ->
1597 ("TIME:"^string_of_float(Unix.gettimeofday()-.initial_time));*)
1598 let proof,metasenv =
1599 ProofEngineHelpers.subst_meta_and_metasenv_in_proof
1600 proof goal subst metasenv
1603 ProofEngineHelpers.compare_metasenvs ~oldmetasenv
1604 ~newmetasenv:metasenv
1607 | Gaveup (tables,cache,maxm) ->
1610 string_of_float(Unix.gettimeofday()-.initial_time)));
1611 raise (ProofEngineTypes.Fail (lazy "Auto gave up"))
1614 let auto_tac ~dbd ~params ~universe =
1615 ProofEngineTypes.mk_tactic (auto_tac ~params ~dbd ~universe);;
1617 let eq_of_goal = function
1618 | Cic.Appl [Cic.MutInd(uri,0,_);_;_;_] when LibraryObjects.is_eq_URI uri ->
1620 | _ -> raise (ProofEngineTypes.Fail (lazy ("The goal is not an equality ")))
1623 (* performs steps of rewrite with the universe, obtaining if possible
1625 let solve_rewrite_tac ~universe ~params:(univ,params) (proof,goal as status)=
1626 let _,metasenv,_subst,_,_,_ = proof in
1627 let _,context,ty = CicUtil.lookup_meta goal metasenv in
1628 let steps = int_of_string (string params "steps" "1") in
1629 let universe = universe_of_params metasenv context universe univ in
1630 let eq_uri = eq_of_goal ty in
1631 let (active,passive,bag), cache, maxm =
1632 (* we take the whole universe (no signature filtering) *)
1633 init_cache_and_tables false true false true universe (proof,goal)
1635 let initgoal = [], metasenv, ty in
1637 let equalities = (Saturation.list_of_passive passive) in
1638 (* we demodulate using both actives passives *)
1639 List.fold_left (fun tbl eq -> Indexing.index tbl eq) (snd active) equalities
1641 let env = metasenv,context,CicUniv.oblivion_ugraph in
1642 match Indexing.solve_demodulating bag env table initgoal steps with
1643 | Some (proof, metasenv, newty) ->
1646 | Cic.Appl[Cic.MutInd _;eq_ty;left;_] ->
1647 Equality.Exact (Equality.refl_proof eq_uri eq_ty left)
1651 Equality.build_goal_proof
1652 bag eq_uri proof refl newty [] context metasenv
1654 ProofEngineTypes.apply_tactic
1655 (PrimitiveTactics.apply_tac ~term:proofterm) status
1658 (ProofEngineTypes.Fail (lazy
1659 ("Unable to solve with " ^ string_of_int steps ^ " demodulations")))
1661 let solve_rewrite_tac ~params ~universe () =
1662 ProofEngineTypes.mk_tactic (solve_rewrite_tac ~universe ~params)
1666 let demodulate_tac ~dbd ~universe ~params:(univ, params) (proof,goal)=
1667 let curi,metasenv,_subst,pbo,pty, attrs = proof in
1668 let metano,context,ty = CicUtil.lookup_meta goal metasenv in
1669 let universe = universe_of_params metasenv context universe univ in
1670 let irl = CicMkImplicit.identity_relocation_list_for_metavariable context in
1671 let initgoal = [], metasenv, ty in
1672 let eq_uri = eq_of_goal ty in
1673 let (active,passive,bag), cache, maxm =
1674 init_cache_and_tables
1675 ~dbd false true true false universe (proof,goal)
1677 let equalities = (Saturation.list_of_passive passive) in
1678 (* we demodulate using both actives passives *)
1681 (fun tbl eq -> Indexing.index tbl eq)
1682 (snd active) equalities
1684 let changed,(newproof,newmetasenv, newty) =
1685 Indexing.demodulation_goal bag
1686 (metasenv,context,CicUniv.oblivion_ugraph) table initgoal
1690 let opengoal = Equality.Exact (Cic.Meta(maxm,irl)) in
1692 Equality.build_goal_proof bag
1693 eq_uri newproof opengoal ty [] context metasenv
1695 let extended_metasenv = (maxm,context,newty)::metasenv in
1696 let extended_status =
1697 (curi,extended_metasenv,_subst,pbo,pty, attrs),goal in
1698 let (status,newgoals) =
1699 ProofEngineTypes.apply_tactic
1700 (PrimitiveTactics.apply_tac ~term:proofterm)
1702 (status,maxm::newgoals)
1704 else (* if newty = ty then *)
1705 raise (ProofEngineTypes.Fail (lazy "no progress"))
1706 (*else ProofEngineTypes.apply_tactic
1707 (ReductionTactics.simpl_tac
1708 ~pattern:(ProofEngineTypes.conclusion_pattern None)) initialstatus*)
1711 let demodulate_tac ~dbd ~params ~universe =
1712 ProofEngineTypes.mk_tactic (demodulate_tac ~dbd ~params ~universe);;
1714 let pp_proofterm = Equality.pp_proofterm;;
1716 let revision = "$Revision$";;
1717 let size_and_depth context metasenv t = 100, 100