exception Uncertain of string Lazy.t;;
exception AssertFailure of string Lazy.t;;
-let refiner_typeof =
- ref (fun _ ?localise _ _ _ _ _ -> ignore localise; assert false);;
-let set_refiner_typeof f = refiner_typeof := f
-;;
-
let (===) x y = Pervasives.compare x y = 0 ;;
let uncert_exc metasenv subst context t1 t2 =
prerr_endline (Printf.sprintf "%-20s" !indent ^ " " ^ Lazy.force s)
;;
-let ppcontext = NCicPp.ppcontext;;
-let ppmetasenv = NCicPp.ppmetasenv;;
+let pp _ = ();;
-let ppcontext ~metasenv:_metasenv ~subst:_subst _context = "...";;
-let ppmetasenv ~subst:_subst _metasenv = "...";;
+let ppcontext ~metasenv ~subst c =
+ "\nctx:\n"^ NCicPp.ppcontext ~metasenv ~subst c
+;;
+let ppmetasenv ~subst m = "\nmenv:\n" ^ NCicPp.ppmetasenv ~subst m;;
-let pp _ = ();;
+let ppcontext ~metasenv:_metasenv ~subst:_subst _context = "";;
+let ppmetasenv ~subst:_subst _metasenv = "";;
-let fix_sorts swap metasenv subst context meta t =
+let fix_sorts swap exc t =
let rec aux () = function
| NCic.Sort (NCic.Type u) as orig ->
if swap then
match NCicEnvironment.sup u with
- | None -> prerr_endline "no sup for" ;
- raise (fail_exc metasenv subst context meta t)
+ | None ->
+ prerr_endline ("no sup for " ^ NCicPp.ppterm ~metasenv:[] ~subst:[] ~context:[] orig) ;
+ raise exc
| Some u1 -> if u = u1 then orig else NCic.Sort (NCic.Type u1)
else
NCic.Sort (NCic.Type (
List.map
(fun arg -> arg, NCicTypeChecker.typeof ~metasenv ~subst context arg) args in
let context_of_args = context in
- let mk_appl = function [] -> assert false | [t] -> t | l -> NCic.Appl l in
let rec mk_lambda metasenv subst context n processed_args = function
| [] ->
let metasenv, _, bo, _ =
in
metasenv, subst, bo
| (arg,ty)::tail ->
+ pp(lazy("arg{ " ^
+ NCicPp.ppterm ~metasenv ~subst ~context:context_of_args arg ^ ":" ^
+ NCicPp.ppterm ~metasenv ~subst ~context:context_of_args ty));
+ let metasenv, subst, telescopic_ty =
+ if processed_args = [] then metasenv, subst, ty else
+ let _ = pp(lazy("delift")) in
+ delift_type_wrt_terms rdb metasenv subst context_of_args ty
+ (List.rev processed_args)
+ in
+ pp(lazy("arg}"));
let name = "HBeta"^string_of_int n in
- let metasenv,_,instance,_ =
- NCicMetaSubst.mk_meta metasenv context_of_args `Term in
- let meta_applied = mk_appl (instance::List.rev processed_args) in
-let metasenv,subst,_,_ =
- !refiner_typeof ((rdb :> NRstatus.status)#set_coerc_db NCicCoercion.empty_db) metasenv subst context_of_args meta_applied None
-in
-prerr_endline ("########################## LI1: " ^ NCicPp.ppterm ~metasenv ~subst ~context:context_of_args meta_applied ^ " vs " ^ NCicPp.ppterm ~metasenv ~subst ~context:context_of_args ty);
-prerr_endline (NCicPp.ppcontext ~metasenv ~subst context_of_args);
-prerr_endline (NCicPp.ppmetasenv metasenv ~subst);
- let metasenv,subst =
- unify rdb true metasenv subst context_of_args meta_applied ty in
-prerr_endline "UNIFY FINITA";
- let telescopic_ty = NCicSubstitution.lift n instance in
- let telescopic_ty =
- mk_appl (telescopic_ty :: mk_irl (List.length processed_args)) in
-prerr_endline ("########################## LI: " ^ NCicPp.ppterm ~metasenv ~subst ~context telescopic_ty);
let metasenv, subst, bo =
mk_lambda metasenv subst ((name,NCic.Decl telescopic_ty)::context) (n+1)
(arg::processed_args) tail
in
metasenv, subst, NCic.Lambda (name, telescopic_ty, bo)
in
- mk_lambda metasenv subst context 0 [] argsty
+ pp(lazy("LAMBDA_INTROS{ " ^
+ NCicPp.ppterm ~metasenv ~subst ~context t ^ ":" ^
+ NCicPp.ppterm ~metasenv ~subst ~context tty ^ " over " ^
+ String.concat "," (List.map (NCicPp.ppterm ~metasenv ~subst ~context)args)));
+ let rc = mk_lambda metasenv subst context 0 [] argsty in
+ pp(lazy("LAMBDA_INTROS}"));
+ rc
and instantiate rdb test_eq_only metasenv subst context n lc t swap =
(*D*) inside 'I'; try let rc =
(* fix_sorts swap metasenv subst context (NCic.Meta(n,lc)) t *)
| _ ->
pp (lazy (
- "typeof: " ^ NCicPp.ppterm ~metasenv ~subst ~context t ^ "\nctx:\n"^
- ppcontext ~metasenv ~subst context ^ "\nmenv:\n"^
+ "typeof: " ^ NCicPp.ppterm ~metasenv ~subst ~context t ^
+ ppcontext ~metasenv ~subst context ^
ppmetasenv ~subst metasenv));
+ let exc_to_be = fail_exc metasenv subst context (NCic.Meta (n,lc)) t in
let t, ty_t =
try t, NCicTypeChecker.typeof ~subst ~metasenv context t
with
| NCicTypeChecker.AssertFailure msg ->
(pp (lazy "fine typeof (fallimento)");
- let ft=fix_sorts swap metasenv subst context (NCic.Meta (n,lc)) t in
+ let ft = fix_sorts swap exc_to_be t in
if ft == t then
(prerr_endline ( ("ILLTYPED: " ^
NCicPp.ppterm ~metasenv ~subst ~context t
- ^ "\nBECAUSE:" ^ Lazy.force msg ^ "\nCONTEXT:\n" ^
- ppcontext ~metasenv ~subst context ^ "\nMENV:\n" ^
+ ^ "\nBECAUSE:" ^ Lazy.force msg ^
+ ppcontext ~metasenv ~subst context ^
ppmetasenv ~subst metasenv
));
assert false)
assert false)
| NCicTypeChecker.TypeCheckerFailure msg ->
prerr_endline (Lazy.force msg);
+ prerr_endline (
+ "typeof: " ^ NCicPp.ppterm ~metasenv ~subst ~context t ^
+ ppcontext ~metasenv ~subst context ^
+ ppmetasenv ~subst metasenv);
pp msg; assert false
in
let lty = NCicSubstitution.subst_meta lc ty in
NCicPp.ppterm ~metasenv ~subst ~context lty ^ " === "
^ NCicPp.ppterm ~metasenv ~subst ~context ty_t));
let metasenv,subst =
- unify test_eq_only metasenv subst context lty ty_t in
+ try
+ unify test_eq_only metasenv subst context lty ty_t
+ with NCicEnvironment.BadConstraint _ as exc ->
+ let ty_t = fix_sorts swap exc_to_be ty_t in
+ try unify test_eq_only metasenv subst context lty ty_t
+ with _ -> raise exc in
metasenv, subst, t
in
pp (lazy(string_of_int n ^ " := 111 = "^
in
pp (lazy(string_of_int n ^ " := 222 = "^
NCicPp.ppterm ~metasenv ~subst ~context:ctx t
- ^ "\n" ^ ppmetasenv ~subst metasenv));
+ ^ ppmetasenv ~subst metasenv));
(* Unifying the types may have already instantiated n. *)
try
let _, _,oldt,_ = NCicUtils.lookup_subst n subst in
let fo_unif test_eq_only metasenv subst t1 t2 =
(*D*) inside 'F'; try let rc =
pp (lazy(" " ^ NCicPp.ppterm ~metasenv ~subst ~context t1 ^ " ==?== " ^
- NCicPp.ppterm ~metasenv ~subst ~context t2 ^ "\n" ^ ppmetasenv
+ NCicPp.ppterm ~metasenv ~subst ~context t2 ^ ppmetasenv
~subst metasenv));
if t1 === t2 then
metasenv, subst
| _, NCic.Meta (n, _) when is_locked n subst ->
(let (metasenv, subst), i =
match NCicReduction.whd ~subst context t1 with
- | NCic.Appl (NCic.Meta (i,l)::args) when
- not (NCicMetaSubst.flexible subst args)
- ->
+ | NCic.Appl (NCic.Meta (i,l)::args) ->
let metasenv, subst, lambda_Mj =
lambda_intros rdb metasenv subst context t1 args
in
-prerr_endline ("XXXXXXXXX " ^ NCicPp.ppterm ~metasenv ~subst ~context lambda_Mj);
unify rdb test_eq_only metasenv subst context
(C.Meta (i,l)) lambda_Mj,
i
| NCic.Meta (i,_) -> (metasenv, subst), i
- | _ -> assert false
+ | _ ->
+ raise (UnificationFailure (lazy "Locked term vs non
+ flexible term; probably not saturated enough yet!"))
in
let t1 = NCicReduction.whd ~subst context t1 in
let j, lj =
with Invalid_argument _ ->
raise (fail_exc metasenv subst context t1 t2))
- | NCic.Appl (NCic.Meta (i,l)::args), _ when
- not (NCicMetaSubst.flexible subst args) ->
- (* we verify that none of the args is a Meta,
- since beta expanding w.r.t a metavariable makes no sense *)
- let metasenv, subst, lambda_Mj =
- lambda_intros rdb metasenv subst context t1 args
- in
- let metasenv, subst =
- unify rdb test_eq_only metasenv subst context
- (C.Meta (i,l)) lambda_Mj
- in
- let metasenv, subst =
- unify rdb test_eq_only metasenv subst context t1 t2
- in
- (try
- let name, ctx, term, ty = NCicUtils.lookup_subst i subst in
- let term = eta_reduce subst term in
- let subst = List.filter (fun (j,_) -> j <> i) subst in
- metasenv, ((i, (name, ctx, term, ty)) :: subst)
- with Not_found -> assert false)
-
- | _, NCic.Appl (NCic.Meta (i,l)::args) when
- not(NCicMetaSubst.flexible subst args) ->
- let metasenv, subst, lambda_Mj =
- lambda_intros rdb metasenv subst context t2 args
- in
- let metasenv, subst =
- unify rdb test_eq_only metasenv subst context
- lambda_Mj (C.Meta (i,l))
- in
- let metasenv, subst =
- unify rdb test_eq_only metasenv subst context t1 t2
- in
- (try
- let name, ctx, term, ty = NCicUtils.lookup_subst i subst in
- let term = eta_reduce subst term in
- let subst = List.filter (fun (j,_) -> j <> i) subst in
- metasenv, ((i, (name, ctx, term, ty)) :: subst)
- with Not_found -> assert false)
+ | NCic.Appl (NCic.Meta (i,l)::args), _ ->
+ let metasenv, subst, lambda_Mj =
+ lambda_intros rdb metasenv subst context t1 args
+ in
+ let metasenv, subst =
+ unify rdb test_eq_only metasenv subst context
+ (C.Meta (i,l)) lambda_Mj
+ in
+ let metasenv, subst =
+ unify rdb test_eq_only metasenv subst context t1 t2
+ in
+ (try
+ let name, ctx, term, ty = NCicUtils.lookup_subst i subst in
+ let term = eta_reduce subst term in
+ let subst = List.filter (fun (j,_) -> j <> i) subst in
+ metasenv, ((i, (name, ctx, term, ty)) :: subst)
+ with Not_found -> assert false)
+
+ | _, NCic.Appl (NCic.Meta (i,l)::args) ->
+ let metasenv, subst, lambda_Mj =
+ lambda_intros rdb metasenv subst context t2 args
+ in
+ let metasenv, subst =
+ unify rdb test_eq_only metasenv subst context
+ lambda_Mj (C.Meta (i,l))
+ in
+ let metasenv, subst =
+ unify rdb test_eq_only metasenv subst context t1 t2
+ in
+ (try
+ let name, ctx, term, ty = NCicUtils.lookup_subst i subst in
+ let term = eta_reduce subst term in
+ let subst = List.filter (fun (j,_) -> j <> i) subst in
+ metasenv, ((i, (name, ctx, term, ty)) :: subst)
+ with Not_found -> assert false)
(* processing this case here we avoid a useless small delta step *)
| (C.Appl ((C.Const r1) as _hd1::tl1), C.Appl (C.Const r2::tl2))
| _ -> [] *) in
let unif_from_stack t1 t2 b metasenv subst =
try
- let t1 = NCicReduction.from_stack t1 in
- let t2 = NCicReduction.from_stack t2 in
+ let t1 = NCicReduction.from_stack ~delta:max_int t1 in
+ let t2 = NCicReduction.from_stack ~delta:max_int t2 in
unif_machines metasenv subst (put_in_whd t1 t2)
with UnificationFailure _ | Uncertain _ when not b ->
metasenv, subst
| UnificationFailure _ -> raise (UnificationFailure msg)
| Uncertain _ -> raise exn
(*D*) in outside(); rc with exn -> outside (); raise exn
+
+and delift_type_wrt_terms rdb metasenv subst context t args =
+ let (metasenv, subst), t =
+ try
+ NCicMetaSubst.delift
+ ~unify:(fun m s c t1 t2 ->
+ let ind = !indent in
+ let res =
+ try Some (unify rdb false m s c t1 t2 )
+ with UnificationFailure _ | Uncertain _ -> None
+ in
+ indent := ind; res)
+ metasenv subst context 0 (0,NCic.Ctx (args @
+ List.rev (mk_irl (List.length context)))) t
+ with NCicMetaSubst.MetaSubstFailure _ -> (metasenv, subst), t
+ in
+ metasenv, subst, t
;;
+
let unify rdb ?(test_eq_only=false) =
indent := "";
unify rdb test_eq_only;;
+
+let fix_sorts = fix_sorts true (UnificationFailure (lazy "no sup"));;
projects / helm.git / blobdiff