X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fsoftware%2Fcomponents%2Fng_refiner%2FnCicUnification.ml;h=1a667770b4ec47b762c8c3d27e090310d2f16f4b;hb=57a360d659425ce1ee9a69516b66a4d3c7b8eb62;hp=3000b7311dca621bcedfc3464380621c13d3e2a6;hpb=1c950d8cfe400f6b68eee7a67c555549db3a4d36;p=helm.git diff --git a/helm/software/components/ng_refiner/nCicUnification.ml b/helm/software/components/ng_refiner/nCicUnification.ml index 3000b7311..1a667770b 100644 --- a/helm/software/components/ng_refiner/nCicUnification.ml +++ b/helm/software/components/ng_refiner/nCicUnification.ml @@ -14,20 +14,17 @@ exception UnificationFailure of string Lazy.t;; exception Uncertain of string Lazy.t;; exception AssertFailure of string Lazy.t;; +exception KeepReducing of string Lazy.t;; +exception KeepReducingThis of + string Lazy.t * (NCicReduction.machine * bool) * + (NCicReduction.machine * bool) ;; let (===) x y = Pervasives.compare x y = 0 ;; -let uncert_exc metasenv subst context t1 t2 = - Uncertain (lazy ( +let mk_msg metasenv subst context t1 t2 = + (lazy ( "Can't unify " ^ NCicPp.ppterm ~metasenv ~subst ~context t1 ^ " with " ^ NCicPp.ppterm ~metasenv ~subst ~context t2)) -;; - -let fail_exc metasenv subst context t1 t2 = - UnificationFailure (lazy ( - "Can't unify " ^ NCicPp.ppterm ~metasenv ~subst ~context t1 ^ - " with " ^ NCicPp.ppterm ~metasenv ~subst ~context t2)); -;; let mk_appl ~upto hd tl = NCicReduction.head_beta_reduce ~upto @@ -78,171 +75,340 @@ let eta_reduce subst t = module C = NCic;; module Ref = NReference;; +let debug = ref false;; let indent = ref "";; -let inside c = indent := !indent ^ String.make 1 c;; -let outside () = indent := String.sub !indent 0 (String.length !indent -1);; - -let pp s = +let times = ref [];; +let pp s = + if !debug then prerr_endline (Printf.sprintf "%-20s" !indent ^ " " ^ Lazy.force s) -;; - -let pp _ = ();; - -let fix_sorts swap metasenv subst context meta 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) - | Some u1 -> if u = u1 then orig else NCic.Sort (NCic.Type u1) - else - NCic.Sort (NCic.Type ( - match NCicEnvironment.sup NCicEnvironment.type0 with - | Some x -> x - | _ -> assert false)) - | NCic.Meta _ as orig -> orig - | t -> NCicUtils.map (fun _ _ -> ()) () aux t - in - aux () t ;; +let inside c = + if !debug then + begin + let time1 = Unix.gettimeofday () in + indent := !indent ^ String.make 1 c; + times := time1 :: !times; + prerr_endline ("{{{" ^ !indent ^ " ") + end +;; +let outside exc_opt = + if !debug then + begin + let time2 = Unix.gettimeofday () in + let time1 = + match !times with time1::tl -> times := tl; time1 | [] -> assert false in + prerr_endline ("}}} " ^ string_of_float (time2 -. time1)); + (match exc_opt with + | Some e -> prerr_endline ("exception raised: " ^ Printexc.to_string e) + | None -> ()); + try + indent := String.sub !indent 0 (String.length !indent -1) + with + Invalid_argument _ -> indent := "??"; () + end +;; + +let ppcontext ~metasenv ~subst c = + "\nctx:\n"^ NCicPp.ppcontext ~metasenv ~subst c +;; +let ppmetasenv ~subst m = "\nmenv:\n" ^ NCicPp.ppmetasenv ~subst m;; + +let ppcontext ~metasenv:_metasenv ~subst:_subst _context = "";; +let ppmetasenv ~subst:_subst _metasenv = "";; +let ppterm ~metasenv ~subst ~context = NCicPp.ppterm ~metasenv ~subst ~context;; +(* let ppterm ~metasenv:_ ~subst:_ ~context:_ _ = "";; *) let is_locked n subst = try match NCicUtils.lookup_subst n subst with - | Some tag, _,_,_ when NCicMetaSubst.is_out_scope_tag tag -> true + | tag, _,_,_ when NCicMetaSubst.is_out_scope_tag tag -> true | _ -> false with NCicUtils.Subst_not_found _ -> false ;; +let rec mk_irl stop base = + if base > stop then [] + else (NCic.Rel base) :: mk_irl stop (base+1) +;; + +(* the argument must be a term in whd *) +let rec could_reduce = + function + | C.Meta _ -> true + | C.Appl (C.Const (Ref.Ref (_,Ref.Fix (_,recno,_)))::args) + when List.length args > recno -> could_reduce (List.nth args recno) + | C.Match (_,_,arg,_) -> could_reduce arg + | C.Appl (he::_) -> could_reduce he + | C.Sort _ | C.Rel _ | C.Prod _ | C.Lambda _ | C.Const _ -> false + | C.Appl [] | C.LetIn _ | C.Implicit _ -> assert false +;; -let rec lambda_intros metasenv subst context t args = - let tty = NCicTypeChecker.typeof ~metasenv ~subst context t in - let argsty = List.map (NCicTypeChecker.typeof ~metasenv ~subst context) args in - let rec mk_lambda context n = function - | [] -> +let rec lambda_intros rdb metasenv subst context argsno ty = + pp (lazy ("LAMBDA INTROS: " ^ ppterm ~metasenv ~subst ~context ty)); + match argsno with + 0 -> let metasenv, _, bo, _ = - NCicMetaSubst.mk_meta metasenv context - (`WithType (NCicSubstitution.lift n tty)) + NCicMetaSubst.mk_meta metasenv context ~with_type:ty `IsTerm in metasenv, bo - | ty::tail -> - let name = "HBeta"^string_of_int n in - let ty = NCicSubstitution.lift n ty in - let metasenv, bo = mk_lambda ((name,NCic.Decl ty)::context) (n+1) tail in - metasenv, NCic.Lambda (name, ty, bo) + | _ -> + (match NCicReduction.whd ~subst context ty with + C.Prod (n,so,ta) -> + let metasenv,bo = + lambda_intros rdb metasenv subst + ((n,C.Decl so)::context) (argsno - 1) ta + in + metasenv,C.Lambda (n,so,bo) + | _ -> assert false) +;; + +let unopt exc = function None -> raise exc | Some x -> x ;; + +let fix metasenv subst is_sup test_eq_only exc t = + (*D*) inside 'f'; try let rc = + pp (lazy (NCicPp.ppterm ~metasenv ~subst ~context:[] t)); + let rec aux test_eq_only metasenv = function + | NCic.Prod (n,so,ta) -> + let metasenv,so = aux true metasenv so in + let metasenv,ta = aux test_eq_only metasenv ta in + metasenv,NCic.Prod (n,so,ta) + | NCic.Sort (NCic.Type [(`CProp|`Type),_]) as orig when test_eq_only -> + metasenv,orig + | NCic.Sort (NCic.Type _) when test_eq_only -> raise exc + | NCic.Sort (NCic.Type u) when is_sup -> + metasenv, NCic.Sort (NCic.Type (unopt exc (NCicEnvironment.sup u))) + | NCic.Sort (NCic.Type u) -> + metasenv, NCic.Sort (NCic.Type + (unopt exc (NCicEnvironment.inf ~strict:false u))) + | NCic.Meta (n,_) as orig -> + (try + let _,_,_,_ = NCicUtils.lookup_subst n subst in metasenv,orig + with NCicUtils.Subst_not_found _ -> + let metasenv, _ = NCicMetaSubst.extend_meta metasenv n in + metasenv, orig) + | t -> + NCicUntrusted.map_term_fold_a (fun _ x -> x) test_eq_only aux metasenv t + in + aux test_eq_only metasenv t + (*D*) in outside None; rc with exn -> outside (Some exn); raise exn +;; + +let metasenv_to_subst n (kind,context,ty) metasenv subst = + let infos,metasenv = List.partition (fun (n',_) -> n = n') metasenv in + let attrs,octx,oty = match infos with [_,infos] -> infos | _ -> assert false in + if octx=context && oty=ty then + (n,(NCicUntrusted.set_kind kind attrs, octx, oty))::metasenv,subst + else + let metasenv, _, bo, _ = + NCicMetaSubst.mk_meta metasenv context ~attrs ~with_type:ty kind in + let subst = (n,(NCicUntrusted.set_kind kind attrs,octx,bo,oty))::subst in + metasenv,subst +;; + +let rec sortfy exc metasenv subst context t = + let t = NCicReduction.whd ~subst context t in + let metasenv,subst = + match t with + | NCic.Sort _ -> metasenv, subst + | NCic.Meta (n,_) -> + let attrs, context, ty = NCicUtils.lookup_meta n metasenv in + let kind = NCicUntrusted.kind_of_meta attrs in + if kind = `IsSort then + metasenv,subst + else + (match ty with + | NCic.Implicit (`Typeof _) -> + metasenv_to_subst n (`IsSort,[],ty) metasenv subst + | ty -> + let metasenv,subst,ty = sortfy exc metasenv subst context ty in + metasenv_to_subst n (`IsSort,[],ty) metasenv subst) + | NCic.Implicit _ -> assert false + | _ -> raise exc in - mk_lambda context 0 argsty + metasenv,subst,t -and instantiate hdb test_eq_only metasenv subst context n lc t swap = - (*D*) inside 'I'; try let rc = - pp (lazy(string_of_int n ^ " :=?= "^ - NCicPp.ppterm ~metasenv ~subst ~context t)); - let unify test_eq_only m s c t1 t2 = - if swap then unify hdb test_eq_only m s c t2 t1 - else unify hdb test_eq_only m s c t1 t2 - in - let name, ctx, ty = NCicUtils.lookup_meta n metasenv in - let metasenv, subst, t = - match ty with - | NCic.Implicit (`Typeof _) -> - metasenv,subst, t - (* fix_sorts swap metasenv subst context (NCic.Meta(n,lc)) t *) - | _ -> - pp (lazy ( - "typeof: " ^ NCicPp.ppterm ~metasenv ~subst ~context t ^ "\nctx:\n"^ - NCicPp.ppcontext ~metasenv ~subst context ^ "\nmenv:\n"^ - NCicPp.ppmetasenv ~subst metasenv)); - 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 - if ft == t then - (prerr_endline ( ("ILLTYPED: " ^ - NCicPp.ppterm ~metasenv ~subst ~context t - ^ "\nBECAUSE:" ^ Lazy.force msg ^ "\nCONTEXT:\n" ^ - NCicPp.ppcontext ~metasenv ~subst context ^ "\nMENV:\n" ^ - NCicPp.ppmetasenv ~subst metasenv - )); - assert false) - else - try - pp (lazy ("typeof: " ^ - NCicPp.ppterm ~metasenv ~subst ~context ft)); - ft, NCicTypeChecker.typeof ~subst ~metasenv context ft - with NCicTypeChecker.AssertFailure _ -> - assert false) - | NCicTypeChecker.TypeCheckerFailure msg -> - prerr_endline (Lazy.force msg); - pp msg; assert false - in - let lty = NCicSubstitution.subst_meta lc ty in - match ty_t with - | NCic.Implicit _ -> - raise (UnificationFailure - (lazy "trying to unify a term with a type")) - | ty_t -> - pp (lazy ("On the types: " ^ - NCicPp.ppterm ~metasenv ~subst ~context:ctx ty ^ " ~~~ " ^ - 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 - metasenv, subst, t - in - pp (lazy(string_of_int n ^ " := 111 = "^ - NCicPp.ppterm ~metasenv ~subst ~context t)); - let (metasenv, subst), t = - try - NCicMetaSubst.delift - ~unify:(fun m s c t1 t2 -> - let ind = !indent in - let res = - try Some (unify test_eq_only m s c t1 t2 ) - with UnificationFailure _ | Uncertain _ -> None +let tipify exc metasenv subst context t ty = + let is_type attrs = + match NCicUntrusted.kind_of_meta attrs with + `IsType | `IsSort -> true + | `IsTerm -> false + in + let rec optimize_meta metasenv subst = + function + NCic.Meta (n,lc) -> + (try + let attrs,_,_ = NCicUtils.lookup_meta n metasenv in + if is_type attrs then + metasenv,subst,true + else + let metasenv = + NCicUntrusted.replace_in_metasenv n + (fun attrs,cc,ty -> NCicUntrusted.set_kind `IsType attrs, cc, ty) + metasenv in - indent := ind; res) - metasenv subst context n lc t - with NCicMetaSubst.Uncertain msg -> - pp (lazy ("delift fails: " ^ Lazy.force msg)); - raise (Uncertain msg) - | NCicMetaSubst.MetaSubstFailure msg -> - pp (lazy ("delift fails: " ^ Lazy.force msg)); - raise (UnificationFailure msg) + metasenv,subst,false + with + NCicUtils.Meta_not_found _ -> + let attrs, _,bo,_ = NCicUtils.lookup_subst n subst in + if is_type attrs then + metasenv,subst,true + else + let subst = + NCicUntrusted.replace_in_subst n + (fun attrs,cc,bo,ty->NCicUntrusted.set_kind `IsType attrs,cc,bo,ty) + subst + in + optimize_meta metasenv subst (NCicSubstitution.subst_meta lc bo)) + | _ -> metasenv,subst,false + in + let metasenv,subst,b = optimize_meta metasenv subst t in + if b then + metasenv,subst,t + else + let metasenv,subst,_ = sortfy exc metasenv subst context ty in + metasenv,subst,t +;; + +let rec instantiate rdb test_eq_only metasenv subst context n lc t swap = + (*D*) inside 'I'; try let rc = + pp (lazy(string_of_int n^" :=?= "^ppterm ~metasenv ~subst ~context t)); + let exc = + UnificationFailure (mk_msg metasenv subst context (NCic.Meta (n,lc)) t) in + let move_to_subst i ((_,cc,t,_) as infos) metasenv subst = + let metasenv = List.remove_assoc i metasenv in + pp(lazy(string_of_int n ^ " :==> "^ ppterm ~metasenv ~subst ~context:cc t)); + metasenv, (i,infos) :: subst in - pp (lazy(string_of_int n ^ " := 222 = "^ - NCicPp.ppterm ~metasenv ~subst ~context:ctx t - ^ "\n" ^ NCicPp.ppmetasenv ~subst metasenv)); - (* Unifying the types may have already instantiated n. *) - try - let _, _,oldt,_ = NCicUtils.lookup_subst n subst in - let oldt = NCicSubstitution.subst_meta lc oldt in - let t = NCicSubstitution.subst_meta lc t in - (* conjecture: always fail --> occur check *) - unify test_eq_only metasenv subst context oldt t - with NCicUtils.Subst_not_found _ -> - (* by cumulativity when unify(?,Type_i) - * we could ? := Type_j with j <= i... *) - let subst = (n, (name, ctx, t, ty)) :: subst in - pp (lazy ("?"^string_of_int n^" := "^NCicPp.ppterm - ~metasenv ~subst ~context (NCicSubstitution.subst_meta lc t))); - let metasenv = - List.filter (fun (m,_) -> not (n = m)) metasenv + let delift_to_subst test_eq_only n lc (attrs,cc,ty) t context metasenv subst = + pp (lazy(string_of_int n ^ " := 111 = "^ + ppterm ~metasenv ~subst ~context t)); + let (metasenv, subst), t = + try + NCicMetaSubst.delift + ~unify:(fun m s c t1 t2 -> + let ind = !indent in + let res = + try Some (unify rdb test_eq_only m s c t1 t2 ) + with UnificationFailure _ | Uncertain _ -> None + in + indent := ind; res) + metasenv subst context n lc t + with NCicMetaSubst.Uncertain msg -> + pp (lazy ("delift is uncertain: " ^ Lazy.force msg)); + raise (Uncertain msg) + | NCicMetaSubst.MetaSubstFailure msg -> + pp (lazy ("delift fails: " ^ Lazy.force msg)); + raise (UnificationFailure msg) in - metasenv, subst - (*D*) in outside(); rc with exn -> outside (); raise exn - -and unify hdb test_eq_only metasenv subst context t1 t2 = + pp (lazy(string_of_int n ^ " := 222 = "^ + ppterm ~metasenv ~subst ~context:cc t^ppmetasenv ~subst metasenv)); + (* Unifying the types may have already instantiated n. *) + try + let _, _,oldt,_ = NCicUtils.lookup_subst n subst in + let oldt = NCicSubstitution.subst_meta lc oldt in + let t = NCicSubstitution.subst_meta lc t in + (* conjecture: always fail --> occur check *) + unify rdb test_eq_only metasenv subst context t oldt + with NCicUtils.Subst_not_found _ -> + move_to_subst n (attrs,cc,t,ty) metasenv subst + in + let attrs,cc,ty = NCicUtils.lookup_meta n metasenv in + let kind = NCicUntrusted.kind_of_meta attrs in + let metasenv,t = fix metasenv subst swap test_eq_only exc t in + let ty_t = NCicTypeChecker.typeof ~metasenv ~subst context t in + let metasenv,subst,t = + match kind with + `IsSort -> sortfy exc metasenv subst context t + | `IsType -> tipify exc metasenv subst context t ty_t + | `IsTerm -> metasenv,subst,t in + match kind with + | `IsSort -> + (match ty,t with + NCic.Implicit (`Typeof _), NCic.Sort _ -> + move_to_subst n (attrs,cc,t,ty_t) metasenv subst + | NCic.Sort (NCic.Type u1), NCic.Sort s -> + let s = + match s,swap with + NCic.Type u2, false -> + NCic.Sort (NCic.Type + (unopt exc (NCicEnvironment.inf ~strict:false + (unopt exc (NCicEnvironment.inf ~strict:true u1) @ u2)))) + | NCic.Type u2, true -> + if NCicEnvironment.universe_lt u2 u1 then + NCic.Sort (NCic.Type u2) + else (raise exc) + | NCic.Prop,_ -> NCic.Sort NCic.Prop + in + move_to_subst n (attrs,cc,s,ty) metasenv subst + | NCic.Implicit (`Typeof _), NCic.Meta _ -> + move_to_subst n (attrs,cc,t,ty_t) metasenv subst + | _, NCic.Meta _ + | NCic.Meta _, NCic.Sort _ -> + pp (lazy ("On the types: " ^ + ppterm ~metasenv ~subst ~context ty ^ "=<=" ^ + ppterm ~metasenv ~subst ~context ty_t)); + let metasenv, subst = + unify rdb false metasenv subst context ty_t ty in + delift_to_subst test_eq_only n lc (attrs,cc,ty) t + context metasenv subst + | _ -> assert false) + | `IsType + | `IsTerm -> + (match ty,t with + NCic.Implicit (`Typeof _), _ -> + let (metasenv, subst), ty_t = + try + NCicMetaSubst.delift + ~unify:(fun m s c t1 t2 -> + let ind = !indent in + let res = try Some (unify rdb test_eq_only m s c t1 t2 ) + with UnificationFailure _ | Uncertain _ -> None + in + indent := ind; res) + metasenv subst context n lc ty_t + with NCicMetaSubst.Uncertain msg -> + pp (lazy ("delift is uncertain: " ^ Lazy.force msg)); + raise (Uncertain msg) + | NCicMetaSubst.MetaSubstFailure msg -> + pp (lazy ("delift fails: " ^ Lazy.force msg)); + raise (UnificationFailure msg) + in + delift_to_subst test_eq_only n lc (attrs,cc,ty_t) t context metasenv + subst + | _, _ -> + let lty = NCicSubstitution.subst_meta lc ty in + pp (lazy ("On the types: " ^ + ppterm ~metasenv ~subst ~context lty ^ "=<=" ^ + ppterm ~metasenv ~subst ~context ty_t)); + let metasenv, subst = + unify rdb false metasenv subst context ty_t lty + in + delift_to_subst test_eq_only n lc (attrs,cc,ty) t context metasenv + subst) + (*D*) in outside None; rc with exn -> outside (Some exn); raise exn + +and unify rdb test_eq_only metasenv subst context t1 t2 = (*D*) inside 'U'; try let rc = - let fo_unif test_eq_only metasenv subst t1 t2 = + let fo_unif test_eq_only metasenv subst (norm1,t1) (norm2,t2) = (*D*) inside 'F'; try let rc = - pp (lazy(" " ^ NCicPp.ppterm ~metasenv ~subst ~context t1 ^ " ==?== " ^ - NCicPp.ppterm ~metasenv ~subst ~context t2 ^ "\n" ^ NCicPp.ppmetasenv + pp (lazy(" " ^ ppterm ~metasenv ~subst ~context t1 ^ " ==?== " ^ + ppterm ~metasenv ~subst ~context t2 ^ ppmetasenv + ~subst metasenv)); + pp (lazy(" " ^ ppterm ~metasenv ~subst:[] ~context t1 ^ " ==??== " ^ + ppterm ~metasenv ~subst:[] ~context t2 ^ ppmetasenv ~subst metasenv)); if t1 === t2 then metasenv, subst +(* CSC: To speed up Oliboni's stuff. Why is it necessary, anyway? + else if + NCicUntrusted.metas_of_term subst context t1 = [] && + NCicUntrusted.metas_of_term subst context t2 = [] + then + if NCicReduction.are_convertible ~metasenv ~subst context t1 t2 then + metasenv,subst + else + raise (UnificationFailure (lazy "Closed terms not convertible")) +*) else match (t1,t2) with | C.Appl [_], _ | _, C.Appl [_] | C.Appl [], _ | _, C.Appl [] @@ -251,23 +417,23 @@ and unify hdb test_eq_only metasenv subst context t1 t2 = assert false | (C.Sort (C.Type a), C.Sort (C.Type b)) when not test_eq_only -> if NCicEnvironment.universe_leq a b then metasenv, subst - else raise (fail_exc metasenv subst context t1 t2) + else raise (UnificationFailure (mk_msg metasenv subst context t1 t2)) | (C.Sort (C.Type a), C.Sort (C.Type b)) -> if NCicEnvironment.universe_eq a b then metasenv, subst - else raise (fail_exc metasenv subst context t1 t2) + else raise (UnificationFailure (mk_msg metasenv subst context t1 t2)) | (C.Sort C.Prop,C.Sort (C.Type _)) -> if (not test_eq_only) then metasenv, subst - else raise (fail_exc metasenv subst context t1 t2) + else raise (UnificationFailure (mk_msg metasenv subst context t1 t2)) | (C.Lambda (name1,s1,t1), C.Lambda(_,s2,t2)) | (C.Prod (name1,s1,t1), C.Prod(_,s2,t2)) -> - let metasenv, subst = unify hdb true metasenv subst context s1 s2 in - unify hdb test_eq_only metasenv subst ((name1, C.Decl s1)::context) t1 t2 + let metasenv, subst = unify rdb true metasenv subst context s1 s2 in + unify rdb test_eq_only metasenv subst ((name1, C.Decl s1)::context) t1 t2 | (C.LetIn (name1,ty1,s1,t1), C.LetIn(_,ty2,s2,t2)) -> - let metasenv,subst=unify hdb test_eq_only metasenv subst context ty1 ty2 in - let metasenv,subst=unify hdb test_eq_only metasenv subst context s1 s2 in + let metasenv,subst=unify rdb test_eq_only metasenv subst context ty1 ty2 in + let metasenv,subst=unify rdb test_eq_only metasenv subst context s1 s2 in let context = (name1, C.Def (s1,ty1))::context in - unify hdb test_eq_only metasenv subst context t1 t2 + unify rdb test_eq_only metasenv subst context t1 t2 | (C.Meta (n1,(s1,l1 as lc1)),C.Meta (n2,(s2,l2 as lc2))) when n1 = n2 -> (try @@ -278,7 +444,7 @@ and unify hdb test_eq_only metasenv subst context t1 t2 = (fun t1 t2 (metasenv, subst, to_restrict, i) -> try let metasenv, subst = - unify hdb test_eq_only metasenv subst context + unify rdb test_eq_only metasenv subst context (NCicSubstitution.lift s1 t1) (NCicSubstitution.lift s2 t2) in metasenv, subst, to_restrict, i-1 @@ -299,30 +465,52 @@ and unify hdb test_eq_only metasenv subst context t1 t2 = let _,_,term,_ = NCicUtils.lookup_subst n1 subst in let term1 = NCicSubstitution.subst_meta lc1 term in let term2 = NCicSubstitution.subst_meta lc2 term in - unify hdb test_eq_only metasenv subst context term1 term2 + unify rdb test_eq_only metasenv subst context term1 term2 with NCicUtils.Subst_not_found _-> raise (UnificationFailure msg)) + + | NCic.Appl (NCic.Meta (i,_)::_ as l1), + NCic.Appl (NCic.Meta (j,_)::_ as l2) when i=j -> + (try + List.fold_left2 + (fun (metasenv, subst) t1 t2 -> + unify rdb test_eq_only metasenv subst context t1 t2) + (metasenv,subst) l1 l2 + with Invalid_argument _ -> + raise (UnificationFailure (mk_msg metasenv subst context t1 t2))) | _, 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) as meta :: args) -> let metasenv, lambda_Mj = - lambda_intros metasenv subst context t1 args + lambda_intros rdb metasenv subst context (List.length args) + (NCicTypeChecker.typeof ~metasenv ~subst context meta) in - unify hdb test_eq_only metasenv subst context + 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 = match t1 with NCic.Meta (j,l) -> j, l | _ -> assert false in let metasenv, subst = - instantiate hdb test_eq_only metasenv subst context j lj t2 true + instantiate rdb test_eq_only metasenv subst context j lj t2 true + in + (* We need to remove the out_scope_tags to avoid propagation of + them that triggers again the ad-hoc case *) + let subst = + List.map (fun (i,(tag,ctx,bo,ty)) -> + let tag = + List.filter + (function `InScope | `OutScope _ -> false | _ -> true) tag + in + i,(tag,ctx,bo,ty) + ) subst in (try let name, ctx, term, ty = NCicUtils.lookup_subst i subst in @@ -331,96 +519,86 @@ and unify hdb test_eq_only metasenv subst context t1 t2 = metasenv, ((i, (name, ctx, term, ty)) :: subst) with Not_found -> assert false)) - | C.Meta (n,lc), t -> - (try - let _,_,term,_ = NCicUtils.lookup_subst n subst in - let term = NCicSubstitution.subst_meta lc term in - unify hdb test_eq_only metasenv subst context term t - with NCicUtils.Subst_not_found _-> - instantiate hdb test_eq_only metasenv subst context n lc - (NCicReduction.head_beta_reduce ~subst t) false) + | C.Meta (n,lc), t when List.mem_assoc n subst -> + let _,_,term,_ = NCicUtils.lookup_subst n subst in + let term = NCicSubstitution.subst_meta lc term in + unify rdb test_eq_only metasenv subst context term t - | t, C.Meta (n,lc) -> - (try - let _,_,term,_ = NCicUtils.lookup_subst n subst in - let term = NCicSubstitution.subst_meta lc term in - unify hdb test_eq_only metasenv subst context t term - with NCicUtils.Subst_not_found _-> - instantiate hdb test_eq_only metasenv subst context n lc - (NCicReduction.head_beta_reduce ~subst t) true) + | t, C.Meta (n,lc) when List.mem_assoc n subst -> + let _,_,term,_ = NCicUtils.lookup_subst n subst in + let term = NCicSubstitution.subst_meta lc term in + unify rdb test_eq_only metasenv subst context t term | NCic.Appl (NCic.Meta (i,l)::args), _ when List.mem_assoc i subst -> let _,_,term,_ = NCicUtils.lookup_subst i subst in let term = NCicSubstitution.subst_meta l term in - unify hdb test_eq_only metasenv subst context + unify rdb test_eq_only metasenv subst context (mk_appl ~upto:(List.length args) term args) t2 | _, NCic.Appl (NCic.Meta (i,l)::args) when List.mem_assoc i subst -> let _,_,term,_ = NCicUtils.lookup_subst i subst in let term = NCicSubstitution.subst_meta l term in - unify hdb test_eq_only metasenv subst context t1 + unify rdb test_eq_only metasenv subst context t1 (mk_appl ~upto:(List.length args) term args) - | NCic.Appl (NCic.Meta (i,_)::_ as l1), - NCic.Appl (NCic.Meta (j,_)::_ as l2) when i=j -> - (try - List.fold_left2 - (fun (metasenv, subst) t1 t2 -> - unify hdb test_eq_only metasenv subst context t1 t2) - (metasenv,subst) l1 l2 - 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, lambda_Mj = - lambda_intros metasenv subst context t1 args - in - let metasenv, subst = - unify hdb test_eq_only metasenv subst context - (C.Meta (i,l)) lambda_Mj - in - let metasenv, subst = - unify hdb 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) + | C.Meta (n,lc), t -> + instantiate rdb test_eq_only metasenv subst context n lc + (NCicReduction.head_beta_reduce ~subst t) false - | _, NCic.Appl (NCic.Meta (i,l)::args) when - not(NCicMetaSubst.flexible subst args) -> - let metasenv, lambda_Mj = - lambda_intros metasenv subst context t2 args - in - let metasenv, subst = - unify hdb test_eq_only metasenv subst context - lambda_Mj (C.Meta (i,l)) - in - let metasenv, subst = - unify hdb 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) + | t, C.Meta (n,lc) -> + instantiate rdb test_eq_only metasenv subst context n lc + (NCicReduction.head_beta_reduce ~subst t) true + + | NCic.Appl (NCic.Meta (i,l) as meta :: args), _ -> + let metasenv, lambda_Mj = + lambda_intros rdb metasenv subst context (List.length args) + (NCicTypeChecker.typeof ~metasenv ~subst context meta) + in + let metasenv, subst = + try + unify rdb test_eq_only metasenv subst context + (C.Meta (i,l)) lambda_Mj + with UnificationFailure msg | Uncertain msg when not norm2-> + (* failure: let's try again argument vs argument *) + raise (KeepReducing msg) + 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) as meta :: args) -> + let metasenv, lambda_Mj = + lambda_intros rdb metasenv subst context (List.length args) + (NCicTypeChecker.typeof ~metasenv ~subst context meta) + in + let metasenv, subst = + try + unify rdb test_eq_only metasenv subst context + lambda_Mj (C.Meta (i,l)) + with UnificationFailure msg | Uncertain msg when not norm1 -> + (* failure: let's try again argument vs argument *) + raise (KeepReducing msg) + 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)) when Ref.eq r1 r2 -> let relevance = NCicEnvironment.get_relevance r1 in - let relevance = match r1 with - | Ref.Ref (_,Ref.Con (_,_,lno)) -> - let _,relevance = HExtlib.split_nth lno relevance in - HExtlib.mk_list false lno @ relevance - | _ -> relevance - in let metasenv, subst, _ = try List.fold_left2 @@ -428,14 +606,18 @@ and unify hdb test_eq_only metasenv subst context t1 t2 = let b, relevance = match relevance with b::tl -> b,tl | _ -> true, [] in let metasenv, subst = - try unify hdb test_eq_only metasenv subst context t1 t2 + try unify rdb test_eq_only metasenv subst context t1 t2 with UnificationFailure _ | Uncertain _ when not b -> metasenv, subst in metasenv, subst, relevance) (metasenv, subst, relevance) tl1 tl2 - with Invalid_argument _ -> - raise (uncert_exc metasenv subst context t1 t2) + with + Invalid_argument _ -> + raise (Uncertain (mk_msg metasenv subst context t1 t2)) + | UnificationFailure _ | Uncertain _ when not (norm1 && norm2) -> + raise (KeepReducing (mk_msg metasenv subst context t1 t2)) + | KeepReducing _ | KeepReducingThis _ -> assert false in metasenv, subst @@ -457,69 +639,94 @@ and unify hdb test_eq_only metasenv subst context t1 t2 = | _ -> false in if not (Ref.eq ref1 ref2) then - raise (uncert_exc metasenv subst context t1 t2) + raise (Uncertain (mk_msg metasenv subst context t1 t2)) else let metasenv, subst = - unify hdb test_eq_only metasenv subst context outtype1 outtype2 in + unify rdb test_eq_only metasenv subst context outtype1 outtype2 in let metasenv, subst = - try unify hdb test_eq_only metasenv subst context term1 term2 + try unify rdb test_eq_only metasenv subst context term1 term2 with UnificationFailure _ | Uncertain _ when is_prop -> metasenv, subst in (try List.fold_left2 (fun (metasenv,subst) -> - unify hdb test_eq_only metasenv subst context) + unify rdb test_eq_only metasenv subst context) (metasenv, subst) pl1 pl2 - with Invalid_argument _ -> - raise (uncert_exc metasenv subst context t1 t2)) + with Invalid_argument _ -> assert false) | (C.Implicit _, _) | (_, C.Implicit _) -> assert false - | _ when NCicUntrusted.metas_of_term subst context t1 = [] && - NCicUntrusted.metas_of_term subst context t2 = [] -> - raise (fail_exc metasenv subst context t1 t2) - | _ -> raise (uncert_exc metasenv subst context t1 t2) - (*D*) in outside(); rc with exn -> outside (); raise exn + | _ when norm1 && norm2 -> + if (could_reduce t1 || could_reduce t2) then + raise (Uncertain (mk_msg metasenv subst context t1 t2)) + else + raise (UnificationFailure (mk_msg metasenv subst context t1 t2)) + | _ -> raise (KeepReducing (mk_msg metasenv subst context t1 t2)) + (*D*) in outside None; rc with exn -> outside (Some exn); raise exn in - let try_hints metasenv subst t1 t2 (* exc*) = -(* - prerr_endline ("\nProblema:\n" ^ - NCicPp.ppterm ~metasenv ~subst ~context t1 ^ " =?= " ^ - NCicPp.ppterm ~metasenv ~subst ~context t2); -*) + let try_hints metasenv subst (_,t1 as mt1) (_,t2 as mt2) (* exc*) = + (*D*) inside 'H'; try let rc = + pp(lazy ("\nProblema:\n" ^ + ppterm ~metasenv ~subst ~context t1 ^ " =?= " ^ + ppterm ~metasenv ~subst ~context t2)); let candidates = - NCicUnifHint.look_for_hint hdb metasenv subst context t1 t2 + NCicUnifHint.look_for_hint rdb metasenv subst context t1 t2 in let rec cand_iter = function | [] -> None (* raise exc *) | (metasenv,(c1,c2),premises)::tl -> -(* - prerr_endline ("\nProvo il candidato:\n" ^ + pp (lazy ("\nProvo il candidato:\n" ^ String.concat "\n" (List.map (fun (a,b) -> - NCicPp.ppterm ~metasenv ~subst ~context a ^ " =?= " ^ - NCicPp.ppterm ~metasenv ~subst ~context b) premises) ^ + ppterm ~metasenv ~subst ~context a ^ " =?= " ^ + ppterm ~metasenv ~subst ~context b) premises) ^ "\n-------------------------------------------\n"^ - NCicPp.ppterm ~metasenv ~subst ~context c1 ^ " = " ^ - NCicPp.ppterm ~metasenv ~subst ~context c2); -*) + ppterm ~metasenv ~subst ~context c1 ^ " = " ^ + ppterm ~metasenv ~subst ~context c2)); try + (*D*) inside 'K'; try let rc = let metasenv,subst = - fo_unif test_eq_only metasenv subst t1 c1 in + fo_unif test_eq_only metasenv subst mt1 (false,c1) in let metasenv,subst = - fo_unif test_eq_only metasenv subst c2 t2 in + fo_unif test_eq_only metasenv subst (false,c2) mt2 in let metasenv,subst = List.fold_left (fun (metasenv, subst) (x,y) -> - unify hdb test_eq_only metasenv subst context x y) + unify rdb test_eq_only metasenv subst context x y) (metasenv, subst) premises in + pp(lazy("FUNZIONA!")); Some (metasenv, subst) + (*D*) in outside None; rc with exn -> outside (Some exn); raise exn with - UnificationFailure _ | Uncertain _ -> - cand_iter tl + KeepReducing _ | UnificationFailure _ | Uncertain _ -> cand_iter tl + | KeepReducingThis _ -> assert false in cand_iter candidates + (*D*) in outside None; rc with exn -> outside (Some exn); raise exn + in + let put_in_whd m1 m2 = + NCicReduction.reduce_machine ~delta:max_int ~subst context m1, + NCicReduction.reduce_machine ~delta:max_int ~subst context m2 + in + let fo_unif_w_hints test_eq_only metasenv subst (_,t1 as m1) (_,t2 as m2) = + try fo_unif test_eq_only metasenv subst m1 m2 + with + | UnificationFailure _ as exn -> raise exn + | KeepReducing _ | Uncertain _ as exn -> + let (t1,norm1 as tm1),(t2,norm2 as tm2) = + put_in_whd (0,[],t1,[]) (0,[],t2,[]) + in + match + try_hints metasenv subst + (norm1,NCicReduction.unwind t1) (norm2,NCicReduction.unwind t2) + with + | Some x -> x + | None -> + match exn with + | KeepReducing msg -> raise (KeepReducingThis (msg,tm1,tm2)) + | Uncertain _ as exn -> raise exn + | _ -> assert false in let height_of = function | NCic.Const (Ref.Ref (_,Ref.Def h)) @@ -528,18 +735,14 @@ and unify hdb test_eq_only metasenv subst context t1 t2 = | NCic.Appl(NCic.Const(Ref.Ref(_,Ref.Fix (_,_,h)))::_) -> h | _ -> 0 in - let put_in_whd m1 m2 = - NCicReduction.reduce_machine ~delta:max_int ~subst context m1, - NCicReduction.reduce_machine ~delta:max_int ~subst context m2 - in let small_delta_step ~subst ((_,_,t1,_ as m1, norm1) as x1) ((_,_,t2,_ as m2, norm2) as x2) = assert (not (norm1 && norm2)); if norm1 then - x1,NCicReduction.reduce_machine ~delta:(height_of t2 -1) ~subst context m2 + x1,NCicReduction.reduce_machine ~delta:0 ~subst context m2 else if norm2 then - NCicReduction.reduce_machine ~delta:(height_of t1 -1) ~subst context m1,x2 + NCicReduction.reduce_machine ~delta:0 ~subst context m1,x2 else let h1 = height_of t1 in let h2 = height_of t2 in @@ -552,20 +755,20 @@ and unify hdb test_eq_only metasenv subst context t1 t2 = | ((k1,e1,t1,s1),norm1 as m1),((k2,e2,t2,s2),norm2 as m2) -> (*D*) inside 'M'; try let rc = pp (lazy("UM: " ^ - NCicPp.ppterm ~metasenv ~subst ~context + ppterm ~metasenv ~subst ~context (NCicReduction.unwind (k1,e1,t1,s1)) ^ " === " ^ - NCicPp.ppterm ~metasenv ~subst ~context + ppterm ~metasenv ~subst ~context (NCicReduction.unwind (k2,e2,t2,s2)))); -pp (lazy (string_of_bool norm1 ^ " ?? " ^ string_of_bool norm2)); + pp (lazy (string_of_bool norm1 ^ " ?? " ^ string_of_bool norm2)); let relevance = [] (* TO BE UNDERSTOOD match t1 with | C.Const r -> NCicEnvironment.get_relevance r | _ -> [] *) 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 @@ -581,39 +784,63 @@ pp (lazy (string_of_bool norm1 ^ " ?? " ^ string_of_bool norm2)); in let hh1,hh2,todo=check_stack (List.rev s1) (List.rev s2) relevance [] in try - let metasenv,subst = fo_unif test_eq_only metasenv subst hh1 hh2 in + let metasenv,subst = + fo_unif_w_hints test_eq_only metasenv subst (norm1,hh1) (norm2,hh2) in List.fold_left (fun (metasenv,subst) (x1,x2,r) -> unif_from_stack x1 x2 r metasenv subst ) (metasenv,subst) todo - with UnificationFailure _ | Uncertain _ when not (norm1 && norm2) -> + with + | KeepReducing _ -> assert false + | KeepReducingThis _ -> + assert (not (norm1 && norm2)); unif_machines metasenv subst (small_delta_step ~subst m1 m2) - (*D*) in outside(); rc with exn -> outside (); raise exn + | UnificationFailure _ | Uncertain _ when (not (norm1 && norm2)) + -> unif_machines metasenv subst (small_delta_step ~subst m1 m2) + | UnificationFailure msg + when could_reduce (NCicReduction.unwind (fst m1)) + || could_reduce (NCicReduction.unwind (fst m2)) + -> raise (Uncertain msg) + (*D*) in outside None; rc with exn -> outside (Some exn); raise exn in - try fo_unif test_eq_only metasenv subst t1 t2 - with - | UnificationFailure msg as exn -> - (try - unif_machines metasenv subst - (put_in_whd (0,[],t1,[]) (0,[],t2,[])) - with - | UnificationFailure _ -> raise (UnificationFailure msg) - | Uncertain _ -> raise exn) - | Uncertain msg as exn -> - match try_hints metasenv subst t1 t2 with - | Some x -> x - | None -> - try - unif_machines metasenv subst - (put_in_whd (0,[],t1,[]) (0,[],t2,[])) + try fo_unif_w_hints test_eq_only metasenv subst (false,t1) (false,t2) + with + | KeepReducingThis (msg,tm1,tm2) -> + (try + unif_machines metasenv subst (tm1,tm2) with | UnificationFailure _ -> raise (UnificationFailure msg) - | Uncertain _ -> raise exn - (*D*) in outside(); rc with exn -> outside (); raise exn + | Uncertain _ -> raise (Uncertain msg) + | KeepReducing _ -> assert false) + | KeepReducing _ -> assert false + + (*D*) in outside None; rc with KeepReducing _ -> assert false | exn -> outside (Some exn); raise exn + +and delift_type_wrt_terms rdb metasenv subst context t args = + let lc = List.rev args @ mk_irl (List.length context) (List.length args+1) in + 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 lc) t + with + NCicMetaSubst.MetaSubstFailure _ + | NCicMetaSubst.Uncertain _ -> (metasenv, subst), t + in + metasenv, subst, t ;; -let unify hdb = - indent := ""; - unify hdb false;; +let unify rdb ?(test_eq_only=false) = + indent := ""; + unify rdb test_eq_only;; +let fix_sorts m s = + fix m s true false (UnificationFailure (lazy "no sup")) +;;