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=7bec66a77fee305635b0dd6a671762c2c19c67b9;hpb=57c897b886b3cc52c62589b4a6e0b32566c6758a;p=helm.git

diff --git a/helm/software/components/ng_refiner/nCicUnification.ml b/helm/software/components/ng_refiner/nCicUnification.ml
index 7bec66a77..1a667770b 100644
--- a/helm/software/components/ng_refiner/nCicUnification.ml
+++ b/helm/software/components/ng_refiner/nCicUnification.ml
@@ -91,14 +91,16 @@ let inside c =
    prerr_endline ("{{{" ^ !indent ^ " ")
   end
 ;;
-let outside ok =
+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));
-   if not ok then prerr_endline "exception raised!";
+   (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
@@ -113,26 +115,8 @@ let ppmetasenv ~subst m = "\nmenv:\n" ^ NCicPp.ppmetasenv ~subst m;;
 
 let ppcontext ~metasenv:_metasenv ~subst:_subst _context = "";;
 let ppmetasenv ~subst:_subst _metasenv = "";;
-
-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 " ^ 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 (
-           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 ppterm ~metasenv ~subst ~context = NCicPp.ppterm ~metasenv ~subst ~context;;
+(* let ppterm ~metasenv:_ ~subst:_ ~context:_ _ = "";; *)
 
 let is_locked n subst =
    try
@@ -159,222 +143,272 @@ let rec could_reduce =
   | C.Appl [] | C.LetIn _ | C.Implicit _ -> assert false
 ;;
 
-let rec lambda_intros rdb metasenv subst context t args =
- let tty = NCicTypeChecker.typeof ~metasenv ~subst context t in
- let argsty =
-  List.map
-  (fun arg -> arg, NCicTypeChecker.typeof ~metasenv ~subst context arg) args in
- let context_of_args = context in
- let rec mk_lambda metasenv subst context n processed_args = 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, 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 
-           (NCicSubstitution.lift n ty)
-           (List.map (NCicSubstitution.lift n) (List.rev processed_args))
-       in
-       pp(lazy("arg} "^NCicPp.ppterm ~metasenv ~subst ~context telescopic_ty));
-       let name = "HBeta"^string_of_int n in
-       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
- 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 =  
-         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 rdb test_eq_only m s c t2 t1 
-    else unify rdb test_eq_only m s c t1 t2
-  in
-  let has_tag = List.exists in
-  let tags, _, ty = NCicUtils.lookup_meta n metasenv in
-  (* on the types *)
-  let metasenv, subst, t = 
-    match ty with 
-    | NCic.Implicit (`Typeof _) -> 
-         pp(lazy("meta with no type"));
-         assert(has_tag ((=)`IsSort) tags); 
-         metasenv, subst, t
-    | _ ->
-       let exc_to_be =
-        UnificationFailure (mk_msg 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 as exn -> 
-              pp(lazy("we try to fix the sort\n"^
-                Lazy.force msg^"\n"^NCicPp.ppmetasenv ~subst metasenv));
-              let ft = fix_sorts swap exc_to_be t in
-              pp(lazy("unable to fix the sort"));
-              if ft == t then raise exn;
-              (try ft, NCicTypeChecker.typeof ~subst ~metasenv context ft 
-               with NCicTypeChecker.AssertFailure _ -> raise exn)
-         | NCicTypeChecker.TypeCheckerFailure msg ->
-              prerr_endline (Lazy.force msg);
-              prerr_endline (NCicPp.ppterm ~metasenv ~subst ~context t);
-              prerr_endline (ppcontext ~metasenv ~subst context); 
-              prerr_endline (ppmetasenv ~subst metasenv);
-              assert false
-       in
-       match ty_t with
-       | NCic.Implicit (`Typeof _) -> 
-           raise (UnificationFailure(lazy "trying to unify a term with a type"))
-       | _ -> 
-          let lty = NCicSubstitution.subst_meta lc ty in
-          pp (lazy ("On the types: " ^
-              NCicPp.ppterm ~metasenv ~subst ~context lty ^ " === " ^ 
-              NCicPp.ppterm ~metasenv ~subst ~context ty_t)); 
-          let metasenv,subst = 
-           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 
-             | NCicEnvironment.BadConstraint _ 
-             | UnificationFailure _ -> raise exc 
+       metasenv, 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, subst, t
-  in 
-  (* viral sortification *)
-  let is_sort metasenv subst context t = 
-    match NCicReduction.whd ~subst context t with
-    | NCic.Meta (i,_) ->
-         let tags, _, _ = NCicUtils.lookup_meta i metasenv in
-         has_tag ((=) `IsSort) tags
-    | NCic.Sort _ -> true
-    | _ -> false
-  in
-  let rec sortify metasenv subst = function
-    | NCic.Implicit (`Typeof _) -> assert false 
-    | NCic.Sort _ as t -> metasenv, subst, t, 0
-    | NCic.Meta (i,_) as t -> 
-         let tags, context, ty = NCicUtils.lookup_meta i metasenv in
-         if has_tag ((=) `IsSort) tags then metasenv, subst, t, i
-         else
-           let ty = NCicReduction.whd ~subst context ty in
-           let metasenv, subst, ty, _ = sortify metasenv subst ty in
-           let metasenv, j, m, _ = 
-             NCicMetaSubst.mk_meta metasenv ~attrs:[`IsSort] [] (`WithType ty)
-           in
-           pp(lazy("rimpiazzo " ^ string_of_int i^" con "^string_of_int j));
-           let subst_entry = i, (tags, context, m, ty) in
-           let subst = subst_entry :: subst in
-           let metasenv = List.filter (fun x,_ -> i <> x) metasenv in
-           metasenv, subst, m, j 
-    | NCic.Appl (NCic.Meta _ as hd :: args) as t -> 
-           let metasenv, subst, lambda_Mj =
-             lambda_intros rdb metasenv subst context t args
-           in
-           let metasenv,subst= unify true metasenv subst context hd lambda_Mj in
-           let t = NCicReduction.whd ~subst context t in
-           let _result = sortify metasenv subst t in       
-           (* untested, maybe dead, code *) assert false;
-    | t -> 
-         if could_reduce t then raise (Uncertain(lazy "not a sort"))
-         else raise (UnificationFailure(lazy "not a sort"))
-  in
-  let metasenv, subst, _, n = 
-    if has_tag ((=) `IsSort) tags then
-      let m,s,x,_ = sortify metasenv subst (NCicReduction.whd ~subst context t)
-      in m,s,x,n
-    else if is_sort metasenv subst context t then
-      sortify metasenv subst (NCic.Meta (n,lc))
-    else
-      metasenv, subst, NCic.Rel ~-1,n
+           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
-  let tags, ctx, ty = NCicUtils.lookup_meta n metasenv in
-  (* instantiation *)
-  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
+   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
+  metasenv,subst,t
+
+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
-         ^ 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 _ -> 
-    let metasenv, tags = 
-      let rec aux = function
-        | NCic.Meta (j,lc) -> 
-            (try 
-              let _, _, t, _ = NCicUtils.lookup_subst j subst in
-              aux (NCicSubstitution.subst_meta lc t)
-            with NCicUtils.Subst_not_found _ -> 
-              let tags', ctx, ty = NCicUtils.lookup_meta j metasenv in
-              let metasenv = List.remove_assoc j metasenv in
-              let tags = tags @ tags' in
-              (j, (tags, ctx, ty)) :: metasenv, tags)
-        | _ -> metasenv, tags
-      in 
-        aux t
-    in
-    (* by cumulativity when unify(?,Type_i) 
-     * we could ? := Type_j with j <= i... *)
-    let subst = (n, (tags, 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 true; rc with exn -> outside false; raise exn 
+    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 (norm1,t1) (norm2,t2) =
     (*D*) inside 'F'; try let rc =  
-     pp (lazy("  " ^ NCicPp.ppterm ~metasenv ~subst ~context t1 ^ " ==?== " ^ 
-         NCicPp.ppterm ~metasenv ~subst ~context t2 ^ ppmetasenv
+     pp (lazy("  " ^ ppterm ~metasenv ~subst ~context t1 ^ " ==?== " ^ 
+         ppterm ~metasenv ~subst ~context t2 ^ ppmetasenv
          ~subst metasenv));
-     pp (lazy("  " ^ NCicPp.ppterm ~metasenv ~subst:[] ~context t1 ^ " ==??== " ^ 
-         NCicPp.ppterm ~metasenv ~subst:[] ~context t2 ^ ppmetasenv
+     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 [] 
@@ -447,9 +481,10 @@ and unify rdb test_eq_only 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) ->
-                 let metasenv, subst, lambda_Mj =
-                   lambda_intros rdb metasenv subst context t1 args
+              | 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
                    unify rdb test_eq_only metasenv subst context 
                     (C.Meta (i,l)) lambda_Mj,
@@ -514,15 +549,16 @@ and unify rdb test_eq_only metasenv subst context t1 t2 =
           instantiate rdb test_eq_only metasenv subst context n lc 
            (NCicReduction.head_beta_reduce ~subst t) true
 
-       | NCic.Appl (NCic.Meta (i,l)::args), _ ->
-          let metasenv, subst, lambda_Mj =
-            lambda_intros rdb metasenv subst context t1 args
+       | 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 ->
+           with UnificationFailure msg | Uncertain msg when not norm2->
             (* failure: let's try again argument vs argument *)
             raise (KeepReducing msg)
           in
@@ -536,15 +572,16 @@ and unify rdb test_eq_only metasenv subst context t1 t2 =
             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
+       | _, 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 ->
+          with UnificationFailure msg | Uncertain msg when not norm1 ->
            (* failure: let's try again argument vs argument *)
            raise (KeepReducing msg)
          in
@@ -562,15 +599,6 @@ and unify rdb test_eq_only metasenv subst context t1 t2 =
        | (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 =
-                  try snd (HExtlib.split_nth lno relevance)
-                  with Failure _ -> []
-                 in
-                   HExtlib.mk_list false lno @ relevance
-             | _ -> relevance
-           in
            let metasenv, subst, _ = 
              try
                List.fold_left2 
@@ -589,6 +617,7 @@ and unify rdb test_eq_only metasenv subst context t1 t2 =
                  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
 
@@ -632,13 +661,13 @@ and unify rdb test_eq_only 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 true; rc with exn -> outside false; raise exn 
+     (*D*)  in outside None; rc with exn -> outside (Some exn); raise exn 
     in
     let try_hints metasenv subst (_,t1 as mt1) (_,t2 as mt2) (* exc*) =
     (*D*) inside 'H'; try let rc =  
      pp(lazy ("\nProblema:\n" ^
-        NCicPp.ppterm ~metasenv ~subst ~context t1 ^ " =?= " ^
-        NCicPp.ppterm ~metasenv ~subst ~context t2));
+        ppterm ~metasenv ~subst ~context t1 ^ " =?= " ^
+        ppterm ~metasenv ~subst ~context t2));
       let candidates = 
         NCicUnifHint.look_for_hint rdb metasenv subst context t1 t2
       in
@@ -649,11 +678,11 @@ and unify rdb test_eq_only metasenv subst context t1 t2 =
               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 = 
@@ -668,12 +697,13 @@ and unify rdb test_eq_only metasenv subst context t1 t2 =
               in
               pp(lazy("FUNZIONA!"));
               Some (metasenv, subst)
-     (*D*)  in outside true; rc with exn -> outside false; raise exn 
+     (*D*)  in outside None; rc with exn -> outside (Some exn); raise exn 
             with
              KeepReducing _ | UnificationFailure _ | Uncertain _ -> cand_iter tl
+           | KeepReducingThis _ -> assert false
       in
         cand_iter candidates
-     (*D*)  in outside true; rc with exn -> outside false; raise exn 
+     (*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,
@@ -725,10 +755,10 @@ and unify rdb 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));
           let relevance = [] (* TO BE UNDERSTOOD 
@@ -771,7 +801,7 @@ and unify rdb test_eq_only metasenv subst context t1 t2 =
            when could_reduce (NCicReduction.unwind (fst m1))
              || could_reduce (NCicReduction.unwind (fst m2))
            -> raise (Uncertain msg)
-      (*D*)  in outside true; rc with exn -> outside false; raise exn 
+      (*D*)  in outside None; rc with exn -> outside (Some exn); raise exn 
      in
      try fo_unif_w_hints test_eq_only metasenv subst (false,t1) (false,t2)
      with
@@ -784,7 +814,7 @@ and unify rdb test_eq_only metasenv subst context t1 t2 =
           | KeepReducing _ -> assert false)
       | KeepReducing _ -> assert false
 
- (*D*)  in outside true; rc with KeepReducing _ -> assert false | exn -> outside false; raise exn 
+ (*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
@@ -811,4 +841,6 @@ let unify rdb ?(test_eq_only=false) =
   indent := "";      
   unify rdb test_eq_only;;
 
-let fix_sorts = fix_sorts true (UnificationFailure (lazy "no sup"));;
+let fix_sorts m s =
+  fix m s true false (UnificationFailure (lazy "no sup"))
+;;