let module R = CicReduction in
let module S = CicSubstitution in
let module PT = PrimitiveTactics in
- let _,metasenv,_,_ = proof in
- let _,context,ty = CicUtil.lookup_meta goal metasenv in
- let rec find n = function
- hd::tl ->
- (match hd with
+ let _,metasenv,_,_ = proof in
+ let _,context,ty = CicUtil.lookup_meta goal metasenv in
+ let rec find n = function
+ hd::tl ->
+ (match hd with
(Some (_, C.Decl t)) when
- (R.are_convertible context (S.lift n t) ty) -> n
+ fst (R.are_convertible context (S.lift n t) ty
+ CicUniv.empty_ugraph) -> n
| (Some (_, C.Def (_,Some ty'))) when
- (R.are_convertible context ty' ty) -> n
- | (Some (_, C.Def (t,None))) when
- (R.are_convertible context
- (CicTypeChecker.type_of_aux' metasenv context (S.lift n t)) ty) -> n
+ fst (R.are_convertible context (S.lift n ty') ty
+ CicUniv.empty_ugraph) -> n
+ | (Some (_, C.Def (t,None))) ->
+ let ty_t, u = (* TASSI: FIXME *)
+ CicTypeChecker.type_of_aux' metasenv context (S.lift n t)
+ CicUniv.empty_ugraph in
+ let b,_ = R.are_convertible context ty_t ty u in
+ if b then n else find (n+1) tl
| _ -> find (n+1) tl
)
| [] -> raise (PET.Fail "Assumption: No such assumption")
(* ANCORA DA DEBUGGARE *)
exception AllSelectedTermsMustBeConvertible;;
+exception CannotGeneralizeInHypotheses;;
(* serve una funzione che cerchi nel ty dal basso a partire da term, i lambda
e li aggiunga nel context, poi si conta la lunghezza di questo nuovo
contesto e si lifta di tot... COSA SIGNIFICA TUTTO CIO'?????? *)
let generalize_tac
- ?(mk_fresh_name_callback = FreshNamesGenerator.mk_fresh_name) terms
+ ?(mk_fresh_name_callback = FreshNamesGenerator.mk_fresh_name ~subst:[])
+ ~term pattern
=
let module PET = ProofEngineTypes in
- let generalize_tac mk_fresh_name_callback terms status =
+ let generalize_tac mk_fresh_name_callback ~term (hyps_pat,concl_pat) status =
+ if hyps_pat <> [] then raise CannotGeneralizeInHypotheses ;
let (proof, goal) = status in
let module C = Cic in
let module P = PrimitiveTactics in
let module T = Tacticals in
let _,metasenv,_,_ = proof in
let _,context,ty = CicUtil.lookup_meta goal metasenv in
+ let terms =
+ let path =
+ match concl_pat with
+ None -> Cic.Implicit (Some `Hole)
+ | Some path -> path in
+ let roots = ProofEngineHelpers.select ~term:ty ~pattern:path in
+ List.fold_left
+ (fun acc (i, r) ->
+ ProofEngineHelpers.find_subterms
+ ~eq:ProofEngineReduction.alpha_equivalence ~wanted:term r @ acc
+ ) [] roots
+ in
let typ =
- match terms with
- [] -> assert false
- | he::tl ->
- (* We need to check that all the convertibility of all the terms *)
- List.iter
- (function t ->
- if not (CicReduction.are_convertible context he t) then
- raise AllSelectedTermsMustBeConvertible
- ) tl ;
- (CicTypeChecker.type_of_aux' metasenv context he)
+ let typ,u =
+ CicTypeChecker.type_of_aux' metasenv context term CicUniv.empty_ugraph in
+ (* We need to check that all the convertibility of all the terms *)
+ ignore (
+ (* TASSI: FIXME *)
+ List.fold_left
+ (fun u t ->
+ let b,u1 = CicReduction.are_convertible context term t u in
+ if not b then
+ raise AllSelectedTermsMustBeConvertible
+ else
+ u1
+ ) u terms) ;
+ typ
in
PET.apply_tactic
(T.thens
~with_what:(List.map (function _ -> C.Rel 1) terms)
~where:ty)
)))
- ~continuations: [(P.apply_tac ~term:(C.Rel 1)) ; T.id_tac])
+ ~continuations:
+ [(P.apply_tac ~term:(C.Appl [C.Rel 1; CicSubstitution.lift 1 term])) ;
+ T.id_tac])
status
in
- PET.mk_tactic (generalize_tac mk_fresh_name_callback terms)
+ PET.mk_tactic (generalize_tac mk_fresh_name_callback ~term pattern)
;;
-
-