module Ref = NReference
+type ctx =
+ | Ce of NCic.hypothesis * NCic.obj list
+ | Fix of Ref.reference * string * NCic.term
+
+(***** A function to restrict the context of a term getting rid of unsed
+ variables *******)
+
+let restrict octx ctx ot =
+ let odummy = Cic.Implicit None in
+ let dummy = NCic.Meta (~-1,(0,NCic.Irl 0)) in
+ let rec aux m acc ot t =
+ function
+ [],[] -> (ot,t),acc
+ | ohe::otl as octx,he::tl ->
+ if CicTypeChecker.does_not_occur octx 0 1 ot then
+ aux (m+1) acc (CicSubstitution.subst odummy ot)
+ (NCicSubstitution.subst dummy t) (otl,tl)
+ else
+ (match ohe,he with
+ None,_ -> assert false
+ | Some (name,Cic.Decl oty),Ce ((name', NCic.Decl ty),objs) ->
+ aux (m+1) ((m+1,objs,None)::acc) (Cic.Lambda (name,oty,ot))
+ (NCic.Lambda (name',ty,t)) (otl,tl)
+ | Some (name,Cic.Decl oty),Fix (ref,name',ty) ->
+ aux (m+1) ((m+1,[],Some ref)::acc) (Cic.Lambda (name,oty,ot))
+ (NCic.Lambda (name',ty,t)) (otl,tl)
+ | Some (name,Cic.Def (obo,oty)),Ce ((name', NCic.Def (bo,ty)),objs) ->
+ aux (m+1) ((m+1,objs,None)::acc) (Cic.LetIn (name,obo,oty,ot))
+ (NCic.LetIn (name',bo,ty,t)) (otl,tl)
+ | _,_ -> assert false)
+ | _,_ -> assert false in
+ let rec split_lambdas_and_letins octx ctx infos (ote,te) =
+ match infos, ote, te with
+ ([], _, _) -> octx,ctx,ote
+ | ((_,objs,None)::tl, Cic.Lambda(name,oso,ota), NCic.Lambda(name',so,ta)) ->
+ split_lambdas_and_letins ((Some(name,(Cic.Decl oso)))::octx)
+ (Ce ((name',NCic.Decl so),objs)::ctx) tl (ota,ta)
+ | ((_,objs,Some r)::tl,Cic.Lambda(name,oso,ota),NCic.Lambda(name',so,ta)) ->
+ split_lambdas_and_letins ((Some(name,(Cic.Decl oso)))::octx)
+ (Fix (r,name',so)::ctx) tl (ota,ta)
+ | ((_,objs,None)::tl,Cic.LetIn(name,obo,oty,ota),NCic.LetIn(nam',bo,ty,ta))->
+ split_lambdas_and_letins ((Some (name,(Cic.Def (obo,oty))))::octx)
+ (Ce ((nam',NCic.Def (bo,ty)),objs)::ctx) tl (ota,ta)
+ | (_, _, _) -> assert false
+ in
+ let long_t,infos = aux 0 [] ot dummy (octx,ctx) in
+ let clean_octx,clean_ctx,clean_ot= split_lambdas_and_letins [] [] infos long_t
+ in
+(*prerr_endline ("RESTRICT PRIMA: " ^ CicPp.pp ot (List.map (function None -> None | Some (name,_) -> Some name) octx));
+prerr_endline ("RESTRICT DOPO: " ^ CicPp.pp clean_ot (List.map (function None -> None | Some (name,_) -> Some name) clean_octx));
+*)
+ clean_octx,clean_ctx,clean_ot, List.map (fun (rel,_,_) -> rel) infos
+;;
+
+
+(**** The translation itself ****)
+
let cn_to_s = function
| Cic.Anonymous -> "_"
| Cic.Name s -> s
;;
-type ctx =
- | Ce of NCic.hypothesis * NCic.obj list
- | Fix of Ref.reference * string * NCic.term
-
let splat mk_pi ctx t =
List.fold_left
(fun (t,l) c ->
split true 0 1 ctx
;;
-let splat_args_for_rel ctx t =
+let splat_args_for_rel ctx t ?rels n_fix =
+ let rels =
+ match rels with
+ Some rels -> rels
+ | None ->
+ let rec mk_irl = function 0 -> [] | n -> n::mk_irl (n - 1) in
+ mk_irl (List.length ctx)
+ in
let bound, free, _, primo_ce_dopo_fix = context_tassonomy ctx in
if free = 0 then t
else
let rec aux = function
- | 0 -> []
- | n ->
- match List.nth ctx (n+bound) with
- | Fix (refe, _, _) when (n+bound) < primo_ce_dopo_fix ->
- NCic.Const refe :: aux (n-1)
- | Fix _ | Ce ((_, NCic.Decl _),_) -> NCic.Rel (n+bound)::aux (n-1)
- | Ce ((_, NCic.Def _),_) -> aux (n-1)
+ | n,_ when n = bound + n_fix -> []
+ | n,he::tl ->
+ (match List.nth ctx (n-1) with
+ | Fix (refe, _, _) when n < primo_ce_dopo_fix ->
+ NCic.Const refe :: aux (n-1,tl)
+ | Fix _ | Ce ((_, NCic.Decl _),_)-> NCic.Rel (he - n_fix)::aux(n-1,tl)
+ | Ce ((_, NCic.Def _),_) -> aux (n-1,tl))
+ | _,_ -> assert false
in
- NCic.Appl (t:: aux free)
+ NCic.Appl (t:: aux (List.length ctx,rels))
;;
-let splat_args ctx t n_fix =
+let splat_args ctx t n_fix rels =
let bound, free, _, primo_ce_dopo_fix = context_tassonomy ctx in
if ctx = [] then t
else
let rec aux = function
- | 0 -> []
- | n ->
+ | 0,[] -> []
+ | n,he::tl ->
(match List.nth ctx (n-1) with
- | Ce ((_, NCic.Decl _),_) when n <= bound -> NCic.Rel n:: aux (n-1)
+ | Ce ((_, NCic.Decl _),_) when n <= bound -> NCic.Rel he:: aux (n-1,tl)
| Fix (refe, _, _) when n < primo_ce_dopo_fix ->
- splat_args_for_rel ctx (NCic.Const refe):: aux (n-1)
- | Fix _ | Ce ((_, NCic.Decl _),_) -> NCic.Rel (n - n_fix):: aux (n-1)
- | Ce ((_, NCic.Def _),_) -> aux (n - 1)
+ splat_args_for_rel ctx (NCic.Const refe) ~rels n_fix :: aux (n-1,tl)
+ | Fix _ | Ce ((_, NCic.Decl _),_) -> NCic.Rel (he - n_fix)::aux(n-1,tl)
+ | Ce ((_, NCic.Def _),_) -> aux (n - 1,tl)
)
+ | _,_ -> assert false
in
- NCic.Appl (t:: aux (List.length ctx))
+ NCic.Appl (t:: aux ((List.length ctx,rels)))
;;
exception Nothing_to_do;;
(function () -> seed := 0)
;;
+exception NotSimilar
+let alpha t1 t2 ref ref' =
+ let rec aux t1 t2 = match t1,t2 with
+ | NCic.Rel n, NCic.Rel m when n=m -> ()
+ | NCic.Appl l1, NCic.Appl l2 -> List.iter2 aux l1 l2
+ | NCic.Lambda (_,s1,t1), NCic.Lambda (_,s2,t2)
+ | NCic.Prod (_,s1,t1), NCic.Prod (_,s2,t2) -> aux s1 s2; aux t1 t2
+ | NCic.LetIn (_,s1,ty1,t1), NCic.LetIn (_,s2,ty2,t2) ->
+ aux s1 s2; aux ty1 ty2; aux t1 t2
+ | NCic.Const r1,
+ NCic.Const r2 when NReference.eq r1 ref && NReference.eq r2 ref' -> ()
+ | NCic.Const r1, NCic.Const r2 when NReference.eq r1 r2 -> ()
+ | NCic.Meta _,NCic.Meta _ -> ()
+ | NCic.Implicit _,NCic.Implicit _ -> ()
+ | NCic.Sort x,NCic.Sort y when x=y -> ()
+ | NCic.Match (_,t1,t11,tl1), NCic.Match (_,t2,t22,tl2) ->
+ aux t1 t2;aux t11 t22;List.iter2 aux tl1 tl2
+ | _-> raise NotSimilar
+ in
+ try aux t1 t2; true with NotSimilar -> false
+;;
+
+exception Found of NReference.reference;;
+let cache = Hashtbl.create 313;;
+let same_obj ref ref' =
+ function
+ | (_,_,_,_,NCic.Fixpoint (_,l1,_)), (_,_,_,_,NCic.Fixpoint (_,l2,_))
+ when List.for_all2 (fun (_,_,_,ty1,bo1) (_,_,_,ty2,bo2) ->
+ alpha ty1 ty2 ref ref' && alpha bo1 bo2 ref ref') l1 l2 ->
+ true
+ | _ -> false
+;;
+let find_in_cache name obj ref =
+ try
+ List.iter
+ (function (ref',obj') ->
+ let recno, fixno =
+ match ref with
+ NReference.Ref (_,_,NReference.Fix (fixno,recno)) -> recno,fixno
+ | _ -> assert false in
+ let recno',fixno' =
+ match ref' with
+ NReference.Ref (_,_,NReference.Fix (fixno',recno)) -> recno,fixno'
+ | _ -> assert false in
+ if recno = recno' && fixno = fixno' && same_obj ref ref' (obj,obj') then (
+(*
+prerr_endline ("!!!!!!!!!!! CACHE HIT !!!!!!!!!!\n" ^
+NReference.string_of_reference ref ^ "\n" ^
+NReference.string_of_reference ref' ^ "\n");
+*)
+ raise (Found ref'));
+
+(*
+prerr_endline ("CACHE SAME NAME: " ^ NReference.string_of_reference ref ^ " <==> " ^ NReference.string_of_reference ref');
+*)
+
+ ) (Hashtbl.find_all cache name);
+(* prerr_endline "<<< CACHE MISS >>>"; *)
+ begin
+ match obj, ref with
+ | (_,_,_,_,NCic.Fixpoint (true,fl,_)) , NReference.Ref (x,y,NReference.Fix _) ->
+ ignore(List.fold_left (fun i (_,name,rno,_,_) ->
+ let ref = NReference.mk_fix i rno ref in
+ Hashtbl.add cache name (ref,obj);
+ i+1
+ ) 0 fl)
+ | _ -> assert false
+ end;
+ None
+ with Found ref -> Some ref
+;;
+
(* we are lambda-lifting also variables that do not occur *)
(* ctx does not distinguish successive blocks of cofix, since there may be no
* lambda separating them *)
preceed its lefts parameters; in the former case, there is nothing to
permute *)
let rec aux k octx (ctx : ctx list) n_fix uri = function
- | Cic.CoFix (cofixno, fl) ->
+ | Cic.CoFix _ as cofix ->
+ let octx,ctx,fix,rels = restrict octx ctx cofix in
+ let cofixno,fl =
+ match fix with Cic.CoFix (cofixno,fl)->cofixno,fl | _-> assert false in
let buri =
UriManager.uri_of_string
(UriManager.buri_of_uri uri^"/"^
(fun (name,ty,_) (bctx, fixpoints, tys, idx) ->
let ty, fixpoints_ty = aux true octx ctx n_fix uri ty in
let r = Ref.reference_of_ouri buri(Ref.CoFix idx) in
- Fix (r,name,ty) :: bctx, fixpoints_ty @ fixpoints,ty::tys,idx+1)
- fl ([], [], [], 0)
+ bctx @ [Fix (r,name,ty)], fixpoints_ty @ fixpoints,ty::tys,idx-1)
+ fl ([], [], [], List.length fl-1)
in
let bctx = bctx @ ctx in
let n_fl = List.length fl in
in
splat_args ctx
(NCic.Const (Ref.reference_of_ouri buri (Ref.CoFix cofixno)))
- n_fix,
+ n_fix rels,
fixpoints @ [obj]
- | Cic.Fix (fixno, fl) ->
+ | Cic.Fix _ as fix ->
+ let octx,ctx,fix,rels = restrict octx ctx fix in
+ let fixno,fl =
+ match fix with Cic.Fix (fixno,fl) -> fixno,fl | _ -> assert false in
let buri =
UriManager.uri_of_string
(UriManager.buri_of_uri uri^"/"^
let r = (* recno is dummy here, must be lifted by the ctx len *)
Ref.reference_of_ouri buri (Ref.Fix (idx,recno))
in
- Fix (r,name,ty) :: bctx, fixpoints_ty@fixpoints,ty::tys,idx+1)
- fl ([], [], [], 0)
+ bctx @ [Fix (r,name,ty)], fixpoints_ty@fixpoints,ty::tys,idx-1)
+ fl ([], [], [], List.length fl-1)
in
let _, _, free_decls, _ = context_tassonomy (bad_bctx @ ctx) in
let bctx =
in
let obj =
NUri.nuri_of_ouri buri,max_int,[],[],
- NCic.Fixpoint (true, fl, (`Generated, `Definition))
+ NCic.Fixpoint (true, fl, (`Generated, `Definition)) in
+ let r = Ref.reference_of_ouri buri (Ref.Fix (fixno,!rno_fixno)) in
+ let obj,r =
+ let _,name,_,_,_ = List.nth fl fixno in
+ match find_in_cache name obj r with
+ Some r' -> [],r'
+ | None -> [obj],r
in
- splat_args ctx
- (NCic.Const
- (Ref.reference_of_ouri buri (Ref.Fix (fixno,!rno_fixno))))
- n_fix,
- fixpoints @ [obj]
+ splat_args ctx (NCic.Const r) n_fix rels, fixpoints @ obj
| Cic.Rel n ->
let bound, _, _, primo_ce_dopo_fix = context_tassonomy ctx in
(match List.nth ctx (n-1) with
| Fix (r,_,_) when n < primo_ce_dopo_fix ->
- splat_args_for_rel ctx (NCic.Const r), []
+ splat_args_for_rel ctx (NCic.Const r) n_fix, []
| Ce _ when n <= bound -> NCic.Rel n, []
| Fix _ when n <= bound -> assert false
| Fix _ | Ce _ when k = true -> NCic.Rel n, []
NCic.LetIn ("cast", ty, t, NCic.Rel 1), fixpoints_t @ fixpoints_ty
| Cic.Sort Cic.Prop -> NCic.Sort NCic.Prop,[]
| Cic.Sort Cic.CProp -> NCic.Sort NCic.CProp,[]
- | Cic.Sort (Cic.Type _) -> NCic.Sort (NCic.Type 0),[]
+ | Cic.Sort (Cic.Type u) ->
+ NCic.Sort (NCic.Type (CicUniv.get_rank u)),[]
| Cic.Sort Cic.Set -> NCic.Sort (NCic.Type 0),[]
(* calculate depth in the univ_graph*)
| Cic.Appl l ->
([], name, ty, cl)::itl, fix_ty @ fix_cl @ acc)
itl ([],[])
in
- NCic.Inductive(ind, leftno + List.length vars, itl, (`Provided, `Regular)),
+ NCic.Inductive(ind, leftno + List.length
+ (List.filter (fun v ->
+ match fst (CicEnvironment.get_obj CicUniv.oblivion_ugraph v) with
+ Cic.Variable (_,Some _,_,_,_) -> false
+ | Cic.Variable (_,None,_,_,_) -> true
+ | _ -> assert false)
+ vars)
+ , itl, (`Provided, `Regular)),
fix_itl
| Cic.Variable _
| Cic.CurrentProof _ -> assert false
projects / helm.git / blobdiff