X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=components%2Ftactics%2Fdeclarative.ml;h=4a7d3e52c6329263d838cf063b6aa9020743d051;hb=2499f5fdcf4dbfecc6f4fafe925b24ae76f14be8;hp=c22d51af27f8f8c49a8b54a1b5367733eac940dd;hpb=6995a7717fd0c760c0608ed9225e9f2dbc14d7d1;p=helm.git diff --git a/components/tactics/declarative.ml b/components/tactics/declarative.ml index c22d51af2..4a7d3e52c 100644 --- a/components/tactics/declarative.ml +++ b/components/tactics/declarative.ml @@ -1,43 +1,94 @@ +(* Copyright (C) 2006, HELM Team. + * + * This file is part of HELM, an Hypertextual, Electronic + * Library of Mathematics, developed at the Computer Science + * Department, University of Bologna, Italy. + * + * HELM is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * HELM is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with HELM; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, + * MA 02111-1307, USA. + * + * For details, see the HELM World-Wide-Web page, + * http://cs.unibo.it/helm/. + *) + let assume id t = - Tacticals.then_ - ~start: - (Tactics.intros ~howmany:1 - ~mk_fresh_name_callback:(fun _ _ _ ~typ -> Cic.Name id) ()) - ~continuation: - (Tactics.change ~pattern:(None,[id,Cic.Implicit (Some `Hole)],None) - (fun _ metasenv ugraph -> t,metasenv,ugraph)) + Tacticals.then_ + ~start: + (Tactics.intros ~howmany:1 + ~mk_fresh_name_callback:(fun _ _ _ ~typ -> Cic.Name id) ()) + ~continuation: + (Tactics.change ~pattern:(None,[id,Cic.Implicit (Some `Hole)],None) + (fun _ metasenv ugraph -> t,metasenv,ugraph)) ;; -let suppose t id = +let suppose t id ty = +(*BUG: check on t missing *) + let ty = match ty with None -> t | Some ty -> ty in Tacticals.then_ ~start: - (Tactics.intros ~howmany:1 - ~mk_fresh_name_callback:(fun _ _ _ ~typ -> Cic.Name id) ()) + (Tactics.intros ~howmany:1 + ~mk_fresh_name_callback:(fun _ _ _ ~typ -> Cic.Name id) ()) ~continuation: - (Tactics.change ~pattern:(None,[id,Cic.Implicit (Some `Hole)],None) - (fun _ metasenv ugraph -> t,metasenv,ugraph)) + (Tactics.change ~pattern:(None,[id,Cic.Implicit (Some `Hole)],None) + (fun _ metasenv ugraph -> ty,metasenv,ugraph)) ;; -let by_term_we_proved t ty id = - Tacticals.thens - ~start: - (Tactics.cut ty - ~mk_fresh_name_callback:(fun _ _ _ ~typ -> Cic.Name id)) - ~continuations: - [ Tacticals.id_tac ; Tactics.apply t ] +let by_term_we_proved ~dbd t ty id ty' = + let just = + match t with + None -> Tactics.auto ~dbd ~params:[] + | Some t -> Tactics.apply t + in + let continuation = + match ty' with + None -> Tacticals.id_tac + | Some ty' -> + Tactics.change ~pattern:(None,[id,Cic.Implicit (Some `Hole)],None) + (fun _ metasenv ugraph -> ty,metasenv,ugraph) + in + Tacticals.thens + ~start: + (Tactics.cut ty + ~mk_fresh_name_callback:(fun _ _ _ ~typ -> Cic.Name id)) + ~continuations:[ continuation ; just ] ;; -let bydone t = - (Tactics.apply ~term:t) - +let bydone ~dbd t = + let just = + match t with + None -> Tactics.auto ~dbd ~params:[] + | Some t -> Tactics.apply t + in + just ;; -let we_need_to_prove t id = +let we_need_to_prove t id ty = let aux status = + let cont,cutted = + match ty with + None -> Tacticals.id_tac,t + | Some ty -> + Tactics.change ~pattern:(None,[id,Cic.Implicit (Some `Hole)],None) + (fun _ metasenv ugraph -> t,metasenv,ugraph), ty in let proof,goals = ProofEngineTypes.apply_tactic - (Tactics.cut t - ~mk_fresh_name_callback:(fun _ _ _ ~typ -> Cic.Name id)) + (Tacticals.thens + ~start: + (Tactics.cut cutted + ~mk_fresh_name_callback:(fun _ _ _ ~typ -> Cic.Name id)) + ~continuations:[cont]) status in let goals' = @@ -49,3 +100,130 @@ let we_need_to_prove t id = in ProofEngineTypes.mk_tactic aux ;; + +let existselim t id1 t1 id2 t2 = +(*BUG: t1 and t2 not used *) +(*PARSING BUG: t2 is parsed in the current context, but it may + have occurrences of id1 in it *) + Tactics.elim_intros t + ~mk_fresh_name_callback: + (let i = ref 0 in + fun _ _ _ ~typ -> + incr i; + if !i = 1 then Cic.Name id1 else Cic.Name id2) + +let andelim = existselim;; + +let rewritingstep ~dbd lhs rhs just conclude = + let aux ((proof,goal) as status) = + let (curi,metasenv,proofbo,proofty) = proof in + let _,context,_ = CicUtil.lookup_meta goal metasenv in + let eq,trans = + match LibraryObjects.eq_URI () with + None -> raise (ProofEngineTypes.Fail (lazy "You need to register the default equality first. Please use the \"default\" command")) + | Some uri -> + Cic.MutInd (uri,0,[]), Cic.Const (LibraryObjects.trans_eq_URI ~eq:uri,[]) + in + let ty,_ = + CicTypeChecker.type_of_aux' metasenv context rhs CicUniv.empty_ugraph in + let just = + match just with + None -> + Tactics.auto ~dbd + ~params:["paramodulation","on"; "timeout","3"] + | Some just -> Tactics.apply just + in + match lhs with + None -> + let plhs,prhs = + match + fst + (CicTypeChecker.type_of_aux' metasenv context (Cic.Rel 1) + CicUniv.empty_ugraph) + with + Cic.Appl [_;_;plhs;prhs] -> plhs,prhs + | _ -> assert false in + let last_hyp_name = + match context with + (Some (Cic.Name id,_))::_ -> id + | _ -> assert false + in + (match conclude with + None -> + ProofEngineTypes.apply_tactic + (Tacticals.thens + ~start:(Tactics.apply ~term:trans) + ~continuations: + [ Tactics.apply prhs ; + Tactics.apply (Cic.Rel 1) ; + just]) status + | Some name -> + let mk_fresh_name_callback = + fun metasenv context _ ~typ -> + FreshNamesGenerator.mk_fresh_name ~subst:[] + metasenv context name ~typ + in + ProofEngineTypes.apply_tactic + (Tacticals.thens + ~start:(Tactics.cut ~mk_fresh_name_callback + (Cic.Appl [eq ; ty ; plhs ; rhs])) + ~continuations: + [ Tactics.clear ~hyps:[last_hyp_name] ; + Tacticals.thens + ~start:(Tactics.apply ~term:trans) + ~continuations: + [ Tactics.apply prhs ; + Tactics.apply (Cic.Rel 1) ; + just] + ]) status) + | Some lhs -> + match conclude with + None -> ProofEngineTypes.apply_tactic just status + | Some name -> + let mk_fresh_name_callback = + fun metasenv context _ ~typ -> + FreshNamesGenerator.mk_fresh_name ~subst:[] + metasenv context name ~typ + in + ProofEngineTypes.apply_tactic + (Tacticals.thens + ~start: + (Tactics.cut ~mk_fresh_name_callback + (Cic.Appl [eq ; ty ; lhs ; rhs])) + ~continuations:[ Tacticals.id_tac ; just ]) status + in + ProofEngineTypes.mk_tactic aux +;; + +let we_proceed_by_induction_on t pat = + (*BUG here: pat unused *) + Tactics.elim_intros ~depth:0 t +;; + +let case id ~params = + (*BUG here: id unused*) + (*BUG here: it does not verify that the previous branch is closed *) + (*BUG here: the params should be parsed telescopically*) + (*BUG here: the tactic_terms should be terms*) + let rec aux ~params ((proof,goal) as status) = + match params with + [] -> proof,[goal] + | (id,t)::tl -> + match ProofEngineTypes.apply_tactic (assume id t) status with + proof,[goal] -> aux tl (proof,goal) + | _ -> assert false + in + ProofEngineTypes.mk_tactic (aux ~params) +;; + +let thesisbecomes t = +let ty = None in + (*BUG here: missing check on t *) + match ty with + None -> Tacticals.id_tac + | Some ty -> + Tactics.change ~pattern:(None,[],Some (Cic.Implicit (Some `Hole))) + (fun _ metasenv ugraph -> ty,metasenv,ugraph) +;; + +let byinduction t id = suppose t id None;;