X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Focaml%2Fcic_unification%2FcicUnification.ml;h=9db77c5d526200246379772cd0a9a1d8cf78c67a;hb=4167cea65ca58897d1a3dbb81ff95de5074700cc;hp=4a2cb243066b0a1b3efb0be2a7f88a54aaee65b4;hpb=0328c0e2938ce714d5d7358afdca00195577198e;p=helm.git

diff --git a/helm/ocaml/cic_unification/cicUnification.ml b/helm/ocaml/cic_unification/cicUnification.ml
index 4a2cb2430..9db77c5d5 100644
--- a/helm/ocaml/cic_unification/cicUnification.ml
+++ b/helm/ocaml/cic_unification/cicUnification.ml
@@ -23,118 +23,274 @@
  * http://cs.unibo.it/helm/.
  *)
 
-exception UnificationFailed;;
-exception Free;;
-exception OccurCheck;;
-exception RelToHiddenHypothesis;;
-exception OpenTerm;;
+open Printf
 
-(**** DELIFT ****)
+exception UnificationFailure of string Lazy.t;;
+exception Uncertain of string Lazy.t;;
+exception AssertFailure of string Lazy.t;;
 
-(* the delift function takes in input an ordered list of integers [n1,...,nk]
-   and a term t, and relocates rel(nk) to k. Typically, the list of integers 
-   is a parameter of a metavariable occurrence. *)
+let verbose = false;;
+let debug_print = fun _ -> () 
 
-exception NotInTheList;;
+let profiler_toa = HExtlib.profile "fo_unif_subst.type_of_aux'"
+let profiler_beta_expand = HExtlib.profile "fo_unif_subst.beta_expand"
+let profiler_deref = HExtlib.profile "fo_unif_subst.deref'"
+let profiler_are_convertible = HExtlib.profile "fo_unif_subst.are_convertible"
 
-let position n =
-  let rec aux k =
-   function 
-       [] -> raise NotInTheList
-     | (Some (Cic.Rel m))::_ when m=n -> k
-     | _::tl -> aux (k+1) tl in
-  aux 1
-;;
- 
-let restrict to_be_restricted =
-  let rec erase i n = 
-    function
-	[] -> []
-      |	_::tl when List.mem (n,i) to_be_restricted ->
-	  None::(erase (i+1) n tl) 
-      | he::tl -> he::(erase (i+1) n tl) in
-  let rec aux =
-    function 
-	[] -> []
-      |	(n,context,t)::tl -> (n,erase 1 n context,t)::(aux tl) in
-  aux
+let type_of_aux' metasenv subst context term ugraph =
+let foo () =
+  try 
+    CicTypeChecker.type_of_aux' ~subst metasenv context term ugraph 
+  with
+      CicTypeChecker.TypeCheckerFailure msg ->
+        let msg =
+         lazy
+          (sprintf
+           "Kernel Type checking error: 
+%s\n%s\ncontext=\n%s\nmetasenv=\n%s\nsubstitution=\n%s\nException:\n%s.\nToo bad."
+             (CicMetaSubst.ppterm subst term)
+             (CicMetaSubst.ppterm [] term)
+             (CicMetaSubst.ppcontext subst context)
+             (CicMetaSubst.ppmetasenv subst metasenv) 
+             (CicMetaSubst.ppsubst subst) (Lazy.force msg)) in
+        raise (AssertFailure msg)
+    | CicTypeChecker.AssertFailure msg ->
+        let msg = lazy
+         (sprintf
+           "Kernel Type checking assertion failure: 
+%s\n%s\ncontext=\n%s\nmetasenv=\n%s\nsubstitution=\n%s\nException:\n%s.\nToo bad."
+             (CicMetaSubst.ppterm subst term)
+             (CicMetaSubst.ppterm [] term)
+             (CicMetaSubst.ppcontext subst context)
+             (CicMetaSubst.ppmetasenv subst metasenv) 
+             (CicMetaSubst.ppsubst subst) (Lazy.force msg)) in
+        raise (AssertFailure msg)
+in profiler_toa.HExtlib.profile foo ()
 ;;
 
+let exists_a_meta l = 
+  List.exists (function Cic.Meta _ -> true | _ -> false) l
+
+let rec deref subst t =
+  let snd (_,a,_) = a in
+  match t with
+      Cic.Meta(n,l) -> 
+        (try 
+           deref subst
+             (CicSubstitution.subst_meta 
+                l (snd (CicUtil.lookup_subst n subst))) 
+         with 
+             CicUtil.Subst_not_found _ -> t)
+    | Cic.Appl(Cic.Meta(n,l)::args) ->
+        (match deref subst (Cic.Meta(n,l)) with
+           | Cic.Lambda _ as t -> 
+               deref subst (CicReduction.head_beta_reduce (Cic.Appl(t::args)))
+           | r -> Cic.Appl(r::args))
+    | Cic.Appl(((Cic.Lambda _) as t)::args) ->
+           deref subst (CicReduction.head_beta_reduce (Cic.Appl(t::args)))
+    | t -> t
+;; 
+
+let deref subst t =
+ let foo () = deref subst t
+ in profiler_deref.HExtlib.profile foo ()
+
+exception WrongShape;;
+let eta_reduce after_beta_expansion after_beta_expansion_body
+     before_beta_expansion
+ =
+ try
+  match before_beta_expansion,after_beta_expansion_body with
+     Cic.Appl l, Cic.Appl l' ->
+      let rec all_but_last check_last =
+       function
+          [] -> assert false
+        | [Cic.Rel 1] -> []
+        | [_] -> if check_last then raise WrongShape else []
+        | he::tl -> he::(all_but_last check_last tl)
+      in
+       let all_but_last check_last l =
+        match all_but_last check_last l with
+           [] -> assert false
+         | [he] -> he
+         | l -> Cic.Appl l
+       in
+       let t = CicSubstitution.subst (Cic.Rel (-1)) (all_but_last true l') in
+       let all_but_last = all_but_last false l in
+        (* here we should test alpha-equivalence; however we know by
+           construction that here alpha_equivalence is equivalent to = *)
+        if t = all_but_last then
+         all_but_last
+        else
+         after_beta_expansion
+   | _,_ -> after_beta_expansion
+ with
+  WrongShape -> after_beta_expansion
 
-let delift context metasenv l t =
+let rec beta_expand test_equality_only metasenv subst context t arg ugraph =
  let module S = CicSubstitution in
-  let to_be_restricted = ref [] in
-  let rec deliftaux k =
-   let module C = Cic in
-    function
-       C.Rel m -> 
-         if m <=k then
-          C.Rel m   (*CSC: che succede se c'e' un Def? Dovrebbe averlo gia' *)
-                    (*CSC: deliftato la regola per il LetIn                 *)
-         else
-	  (match List.nth context (m-k-1) with
-	    Some (_,C.Def t) -> deliftaux k (S.lift m t)
-	  | Some (_,C.Decl t) ->
-             (* It may augment to_be_restricted *)
-             ignore (deliftaux k (S.lift m t)) ;
-             C.Rel ((position (m-k) l) + k)
-	  | None -> raise RelToHiddenHypothesis)
-     | C.Var _  as t -> t
-     | C.Meta (i, l1) as t -> 
-        let rec deliftl j =
-         function
-            [] -> []
-          | None::tl -> None::(deliftl (j+1) tl)
-          | (Some t)::tl ->
-             let l1' = (deliftl (j+1) tl) in
-              try
-               Some (deliftaux k t)::l1'
-              with
-                 RelToHiddenHypothesis
-               | NotInTheList ->
-                  to_be_restricted := (i,j)::!to_be_restricted ; None::l1'
-        in
-         let l' = deliftl 1 l1 in
-          C.Meta(i,l')
-     | C.Sort _ as t -> t
-     | C.Implicit as t -> t
-     | C.Cast (te,ty) -> C.Cast (deliftaux k te, deliftaux k ty)
-     | C.Prod (n,s,t) -> C.Prod (n, deliftaux k s, deliftaux (k+1) t)
-     | C.Lambda (n,s,t) -> C.Lambda (n, deliftaux k s, deliftaux (k+1) t)
-     | C.LetIn (n,s,t) -> C.LetIn (n, deliftaux k s, deliftaux (k+1) t)
-     | C.Appl l -> C.Appl (List.map (deliftaux k) l)
-     | C.Const _ as t -> t
-     | C.Abst _  as t -> t
-     | C.MutInd _ as t -> t
-     | C.MutConstruct _ as t -> t
-     | C.MutCase (sp,cookingsno,i,outty,t,pl) ->
-        C.MutCase (sp, cookingsno, i, deliftaux k outty, deliftaux k t,
-         List.map (deliftaux k) pl)
-     | C.Fix (i, fl) ->
-        let len = List.length fl in
-        let liftedfl =
-         List.map
-          (fun (name, i, ty, bo) ->
-           (name, i, deliftaux k ty, deliftaux (k+len) bo))
-           fl
-        in
-         C.Fix (i, liftedfl)
-     | C.CoFix (i, fl) ->
-        let len = List.length fl in
-        let liftedfl =
-         List.map
-          (fun (name, ty, bo) -> (name, deliftaux k ty, deliftaux (k+len) bo))
-           fl
-        in
-         C.CoFix (i, liftedfl)
+ let module C = Cic in
+let foo () =
+  let rec aux metasenv subst n context t' ugraph =
+   try
+
+    let subst,metasenv,ugraph1 =
+     fo_unif_subst test_equality_only subst context metasenv 
+      (CicSubstitution.lift n arg) t' ugraph
+
+    in
+     subst,metasenv,C.Rel (1 + n),ugraph1
+   with
+      Uncertain _
+    | UnificationFailure _ ->
+       match t' with
+        | C.Rel m  -> subst,metasenv, 
+           (if m <= n then C.Rel m else C.Rel (m+1)),ugraph
+        | C.Var (uri,exp_named_subst) ->
+           let subst,metasenv,exp_named_subst',ugraph1 =
+            aux_exp_named_subst metasenv subst n context exp_named_subst ugraph
+           in
+            subst,metasenv,C.Var (uri,exp_named_subst'),ugraph1
+        | C.Meta (i,l) ->
+            (* andrea: in general, beta_expand can create badly typed
+             terms. This happens quite seldom in practice, UNLESS we
+             iterate on the local context. For this reason, we renounce
+             to iterate and just lift *)
+            let l = 
+              List.map 
+                (function
+                     Some t -> Some (CicSubstitution.lift 1 t)
+                   | None -> None) l in
+            subst, metasenv, C.Meta (i,l), ugraph
+        | C.Sort _
+        | C.Implicit _ as t -> subst,metasenv,t,ugraph
+        | C.Cast (te,ty) ->
+            let subst,metasenv,te',ugraph1 = 
+              aux metasenv subst n context te ugraph in
+            let subst,metasenv,ty',ugraph2 = 
+              aux metasenv subst n context ty ugraph1 in 
+            (* TASSI: sure this is in serial? *)
+            subst,metasenv,(C.Cast (te', ty')),ugraph2
+        | C.Prod (nn,s,t) ->
+           let subst,metasenv,s',ugraph1 = 
+             aux metasenv subst n context s ugraph in
+           let subst,metasenv,t',ugraph2 =
+             aux metasenv subst (n+1) ((Some (nn, C.Decl s))::context) t 
+               ugraph1
+           in
+           (* TASSI: sure this is in serial? *)
+           subst,metasenv,(C.Prod (nn, s', t')),ugraph2
+        | C.Lambda (nn,s,t) ->
+           let subst,metasenv,s',ugraph1 = 
+             aux metasenv subst n context s ugraph in
+           let subst,metasenv,t',ugraph2 =
+            aux metasenv subst (n+1) ((Some (nn, C.Decl s))::context) t ugraph1
+           in
+           (* TASSI: sure this is in serial? *)
+            subst,metasenv,(C.Lambda (nn, s', t')),ugraph2
+        | C.LetIn (nn,s,t) ->
+           let subst,metasenv,s',ugraph1 = 
+             aux metasenv subst n context s ugraph in
+           let subst,metasenv,t',ugraph2 =
+            aux metasenv subst (n+1) ((Some (nn, C.Def (s,None)))::context) t
+              ugraph1
+           in
+           (* TASSI: sure this is in serial? *)
+            subst,metasenv,(C.LetIn (nn, s', t')),ugraph2
+        | C.Appl l ->
+           let subst,metasenv,revl',ugraph1 =
+            List.fold_left
+             (fun (subst,metasenv,appl,ugraph) t ->
+               let subst,metasenv,t',ugraph1 = 
+                 aux metasenv subst n context t ugraph in
+                subst,metasenv,(t'::appl),ugraph1
+             ) (subst,metasenv,[],ugraph) l
+           in
+            subst,metasenv,(C.Appl (List.rev revl')),ugraph1
+        | C.Const (uri,exp_named_subst) ->
+           let subst,metasenv,exp_named_subst',ugraph1 =
+            aux_exp_named_subst metasenv subst n context exp_named_subst ugraph
+           in
+            subst,metasenv,(C.Const (uri,exp_named_subst')),ugraph1
+        | C.MutInd (uri,i,exp_named_subst) ->
+           let subst,metasenv,exp_named_subst',ugraph1 =
+            aux_exp_named_subst metasenv subst n context exp_named_subst ugraph
+           in
+            subst,metasenv,(C.MutInd (uri,i,exp_named_subst')),ugraph1
+        | C.MutConstruct (uri,i,j,exp_named_subst) ->
+           let subst,metasenv,exp_named_subst',ugraph1 =
+            aux_exp_named_subst metasenv subst n context exp_named_subst ugraph
+           in
+            subst,metasenv,(C.MutConstruct (uri,i,j,exp_named_subst')),ugraph1
+        | C.MutCase (sp,i,outt,t,pl) ->
+           let subst,metasenv,outt',ugraph1 = 
+             aux metasenv subst n context outt ugraph in
+           let subst,metasenv,t',ugraph2 = 
+             aux metasenv subst n context t ugraph1 in
+           let subst,metasenv,revpl',ugraph3 =
+            List.fold_left
+             (fun (subst,metasenv,pl,ugraph) t ->
+               let subst,metasenv,t',ugraph1 = 
+                 aux metasenv subst n context t ugraph in
+               subst,metasenv,(t'::pl),ugraph1
+             ) (subst,metasenv,[],ugraph2) pl
+           in
+           subst,metasenv,(C.MutCase (sp,i,outt', t', List.rev revpl')),ugraph3
+           (* TASSI: not sure this is serial *)
+        | C.Fix (i,fl) ->
+(*CSC: not implemented
+           let tylen = List.length fl in
+            let substitutedfl =
+             List.map
+              (fun (name,i,ty,bo) -> (name, i, aux n ty, aux (n+tylen) bo))
+               fl
+            in
+             C.Fix (i, substitutedfl)
+*)
+            subst,metasenv,(CicSubstitution.lift 1 t' ),ugraph
+        | C.CoFix (i,fl) ->
+(*CSC: not implemented
+           let tylen = List.length fl in
+            let substitutedfl =
+             List.map
+              (fun (name,ty,bo) -> (name, aux n ty, aux (n+tylen) bo))
+               fl
+            in
+             C.CoFix (i, substitutedfl)
+
+*) 
+            subst,metasenv,(CicSubstitution.lift 1 t'), ugraph
+
+  and aux_exp_named_subst metasenv subst n context ens ugraph =
+   List.fold_right
+    (fun (uri,t) (subst,metasenv,l,ugraph) ->
+      let subst,metasenv,t',ugraph1 = aux metasenv subst n context t ugraph in
+       subst,metasenv,((uri,t')::l),ugraph1) ens (subst,metasenv,[],ugraph)
   in
-    let res = deliftaux 0 t in
-    res, restrict !to_be_restricted metasenv
-;;
+  let argty,ugraph1 = type_of_aux' metasenv subst context arg ugraph in
+  let fresh_name =
+   FreshNamesGenerator.mk_fresh_name ~subst
+    metasenv context (Cic.Name "Hbeta") ~typ:argty
+  in
+   let subst,metasenv,t',ugraph2 = aux metasenv subst 0 context t ugraph1 in
+   let t'' = eta_reduce (C.Lambda (fresh_name,argty,t')) t' t in
+   subst, metasenv, t'', ugraph2
+in profiler_beta_expand.HExtlib.profile foo ()
+
 
-(**** END OF DELIFT ****)
+and beta_expand_many test_equality_only metasenv subst context t args ugraph =
+  let subst,metasenv,hd,ugraph =
+    List.fold_right
+      (fun arg (subst,metasenv,t,ugraph) ->
+         let subst,metasenv,t,ugraph1 =
+           beta_expand test_equality_only 
+             metasenv subst context t arg ugraph 
+         in
+           subst,metasenv,t,ugraph1 
+      ) args (subst,metasenv,t,ugraph) 
+  in
+    subst,metasenv,hd,ugraph
 
-type substitution = (int * Cic.term) list
 
 (* NUOVA UNIFICAZIONE *)
 (* A substitution is a (int * Cic.term) list that associates a
@@ -144,462 +300,386 @@ type substitution = (int * Cic.term) list
    fo_unif_new takes a metasenv, a context, two terms t1 and t2 and gives back
    a new substitution which is _NOT_ unwinded. It must be unwinded before
    applying it. *)
- 
-let fo_unif_new metasenv context t1 t2 =
-    let module C = Cic in
-    let module R = CicReduction in
-    let module S = CicSubstitution in
-    let rec fo_unif_aux subst context metasenv t1 t2 =  
-    match (t1, t2) with
-         (C.Meta (n,ln), C.Meta (m,lm)) when n=m ->
-           let ok =
-            List.fold_left2
-             (fun b t1 t2 ->
-               b &&
-                match t1,t2 with
-                  None,_
-                | _,None -> true
-                | Some t1', Some t2' ->
-                   (* First possibility:  restriction    *)
-                   (* Second possibility: unification    *)
-                   (* Third possibility:  convertibility *)
-	           R.are_convertible context t1' t2'
-             ) true ln lm
-           in
-            if ok then subst,metasenv else
-             raise UnificationFailed
-       | (C.Meta (n,l), C.Meta (m,_)) when n>m ->
-	   fo_unif_aux subst context metasenv t2 t1
-       | (C.Meta (n,l), t)   
-       | (t, C.Meta (n,l)) ->
-	   let subst',metasenv' =
-	     try
-	       let oldt = (List.assoc n subst) in
-	       let lifted_oldt = S.lift_meta l oldt in
-	       fo_unif_aux subst context metasenv lifted_oldt t
-	     with Not_found ->
-prerr_endline ("DELIFT2(" ^ CicPp.ppterm t ^ ")") ; flush stderr ;
-List.iter (function (Some t) -> prerr_endline ("l: " ^ CicPp.ppterm t) | None -> prerr_endline " _ ") l ; flush stderr ;
-prerr_endline "<DELIFT2" ; flush stderr ;
-	       let t',metasenv' = delift context metasenv l t in
-	       (n, t')::subst, metasenv'
-	   in
-	    let (_,_,meta_type) = 
-	      List.find (function (m,_,_) -> m=n) metasenv' in
-	    let tyt = CicTypeChecker.type_of_aux' metasenv' context t in
-	     fo_unif_aux subst' context metasenv' (S.lift_meta l meta_type) tyt
-       | (C.Rel _, _)
-       | (_,  C.Rel _) 
-       | (C.Var _, _)
-       | (_, C.Var _) 
-       | (C.Sort _ ,_)
-       | (_, C.Sort _)
-       | (C.Implicit, _)
-       | (_, C.Implicit) -> 
-	   if R.are_convertible context t1 t2 then subst, metasenv
-           else raise UnificationFailed
-       | (C.Cast (te,ty), t2) -> fo_unif_aux subst context metasenv te t2
-       | (t1, C.Cast (te,ty)) -> fo_unif_aux subst context metasenv t1 te
-       | (C.Prod (n1,s1,t1), C.Prod (_,s2,t2)) -> 
-	   let subst',metasenv' = fo_unif_aux subst context metasenv s1 s2 in
-           fo_unif_aux subst' ((Some (n1,(C.Decl s1)))::context) metasenv' t1 t2
-       | (C.Lambda (n1,s1,t1), C.Lambda (_,s2,t2)) -> 
-           let subst',metasenv' = fo_unif_aux subst context metasenv s1 s2 in
-           fo_unif_aux subst' ((Some (n1,(C.Decl s1)))::context) metasenv' t1 t2
-       | (C.LetIn (_,s1,t1), t2)  
-       | (t2, C.LetIn (_,s1,t1)) -> 
-	   fo_unif_aux subst context metasenv t2 (S.subst s1 t1)
-       | (C.Appl l1, C.Appl l2) -> 
-           let lr1 = List.rev l1 in
-           let lr2 = List.rev l2 in
-           let rec fo_unif_l subst metasenv = function
-               [],_
-             | _,[] -> assert false
-             | ([h1],[h2]) ->
-                 fo_unif_aux subst context metasenv h1 h2
-             | ([h],l) 
-             | (l,[h]) ->
-                 fo_unif_aux subst context metasenv h (C.Appl (List.rev l))
-             | ((h1::l1),(h2::l2)) -> 
-		 let subst', metasenv' = 
-		   fo_unif_aux subst context metasenv h1 h2
-                 in 
-                 fo_unif_l subst' metasenv' (l1,l2)
-           in
-	    fo_unif_l subst metasenv (lr1, lr2) 
-       | (C.Const _, _) 
-       | (_, C.Const _)
-       | (C.Abst _, _) 
-       | (_, C.Abst _) 
-       | (C.MutInd  _, _) 
-       | (_, C.MutInd _)
-       | (C.MutConstruct _, _)
-       | (_, C.MutConstruct _) -> 
-	   if R.are_convertible context t1 t2 then subst, metasenv
-           else raise UnificationFailed
-       | (C.MutCase (_,_,_,outt1,t1,pl1), C.MutCase (_,_,_,outt2,t2,pl2))->
-         let subst', metasenv' = 
-	   fo_unif_aux subst context metasenv outt1 outt2 in
-         let subst'',metasenv'' = 
-	   fo_unif_aux subst' context metasenv' t1 t2 in
-         List.fold_left2 
-	   (function (subst,metasenv) ->
-             fo_unif_aux subst context metasenv
-           ) (subst'',metasenv'') pl1 pl2 
-       | (C.Fix _, _)
-       | (_, C.Fix _) 
-       | (C.CoFix _, _)
-       | (_, C.CoFix _) -> 
-	   if R.are_convertible context t1 t2 then subst, metasenv
-           else raise UnificationFailed
-       | (_,_) -> raise UnificationFailed
-   in fo_unif_aux [] context metasenv t1 t2;;
-
-(*CSC: ???????????????
-(* m is the index of a metavariable to restrict, k is nesting depth
-of the occurrence m, and l is its relocation list. canonical_context
-is the context of the metavariable we are instantiating - containing
-m - Only rel in the domain of canonical_context are accessible.
-This function takes in input a metasenv and gives back a metasenv.
-A rel(j) in the canonical context of m, is rel(List.nth l j) for the 
-instance of m under consideration, that is rel (List.nth l j) - k 
-in canonical_context. *)
-
-let restrict canonical_context m k l =
-  let rec erase i = 
-    function
-	[] -> []
-      |	None::tl -> None::(erase (i+1) tl)
-      |	he::tl -> 
-	  let i' = (List.nth l (i-1)) in
-	  if i' <= k 
-	   then he::(erase (i+1) tl) (* local variable *) 
-	   else 
-	    let acc = 
-	      (try List.nth canonical_context (i'-k-1)
-	       with Failure _ -> None) in
-	    if acc = None 
-	     then None::(erase (i+1) tl)
-	     else he::(erase (i+1) tl) in
-  let rec aux =
-    function 
-	[] -> []
-      |	(n,context,t)::tl when n=m -> (n,erase 1 context,t)::tl
-      |	hd::tl -> hd::(aux tl)
-  in
-   aux
-;;
-
-
-let check_accessibility metasenv i =
-  let module C = Cic in
-  let module S = CicSubstitution in
-  let (_,canonical_context,_) = 
-    List.find (function (m,_,_) -> m=i) metasenv in
-   List.map
-    (function t ->
-      let =
-       delift canonical_context metasenv ? t
-    ) canonical_context
-CSCSCS
-
 
-
-  let rec aux metasenv k =
-    function
-      C.Rel i -> 
-       if i <= k then
-        metasenv
-       else 
-        (try
-          match List.nth canonical_context (i-k-1) with
-            Some (_,C.Decl t) 
-          | Some (_,C.Def t) -> aux metasenv k (S.lift i t)
-          | None -> raise RelToHiddenHypothesis
-          with
-           Failure _ -> raise OpenTerm
-        )
-    | C.Var _  -> metasenv
-    | C.Meta (i,l) -> restrict canonical_context i k l metasenv 
-    | C.Sort _ -> metasenv
-    | C.Implicit -> metasenv
-    | C.Cast (te,ty) -> 
-	let metasenv' = aux metasenv k te in
-	aux metasenv' k ty
-    | C.Prod (_,s,t) 
-    | C.Lambda (_,s,t) 
-    | C.LetIn (_,s,t) ->
-	let metasenv' = aux metasenv k s in
-	aux metasenv' (k+1) t
-    | C.Appl l ->
-	List.fold_left
-	  (function metasenv -> aux metasenv k) metasenv l
-    | C.Const _
-    | C.Abst _
-    | C.MutInd _ 
-    | C.MutConstruct _ -> metasenv
-    | C.MutCase (_,_,_,outty,t,pl) ->
-	let metasenv' = aux metasenv k outty in
-	let metasenv'' = aux metasenv' k t in
-	List.fold_left
-	  (function metasenv -> aux metasenv k) metasenv'' pl
-    | C.Fix (i, fl) ->
-       let len = List.length fl in
-       List.fold_left
-         (fun metasenv f ->
-	   let (_,_,ty,bo) = f in
-	   let metasenv' = aux metasenv k ty in
-	   aux metasenv' (k+len) bo
-         ) metasenv fl
-    | C.CoFix (i, fl) ->
-	let len = List.length fl in
-        List.fold_left
-         (fun metasenv f ->
-	   let (_,ty,bo) = f in
-	   let metasenv' = aux metasenv k ty in
-	   aux metasenv' (k+len) bo
-         ) metasenv fl
-  in aux metasenv 0
-;;
-*)
-
-
-let unwind metasenv subst unwinded t =
- let unwinded = ref unwinded in
- let frozen = ref [] in
- let rec um_aux metasenv =
-  let module C = Cic in
-  let module S = CicSubstitution in 
-   function
-      C.Rel _ as t -> t,metasenv
-    | C.Var _  as t -> t,metasenv
-    | C.Meta (i,l) -> 
-	(try
-          S.lift_meta l (List.assoc i !unwinded), metasenv
-         with Not_found ->
-           if List.mem i !frozen then raise OccurCheck
-           else
-            let saved_frozen = !frozen in 
-	    frozen := i::!frozen ;
-            let res =
-             try
-	      let t = List.assoc i subst in
-              let t',metasenv' = um_aux metasenv t in
-	      let _,metasenv'' =
-               let (_,canonical_context,_) = 
-                List.find (function (m,_,_) -> m=i) metasenv
-               in
-prerr_endline ("DELIFT(" ^ CicPp.ppterm t' ^ ")") ; flush stderr ;
-List.iter (function (Some t) -> prerr_endline ("l: " ^ CicPp.ppterm t) | None -> prerr_endline " _ ") l ; flush stderr ;
-prerr_endline "<DELIFT" ; flush stderr ;
-                delift canonical_context metasenv' l t'
-              in
-               unwinded := (i,t')::!unwinded ;
-               S.lift_meta l t', metasenv'
-             with
-              Not_found ->
-               (* not constrained variable, i.e. free in subst*)
-               let l',metasenv' =
-                List.fold_right
-	         (fun t (tl,metasenv) ->
-                   match t with
-                      None -> None::tl,metasenv
-                    | Some t -> 
-	               let t',metasenv' = um_aux metasenv t in
-	                (Some t')::tl, metasenv'
-	         ) l ([],metasenv)
-               in
-                C.Meta (i,l'), metasenv'
-            in
-            frozen := saved_frozen ;
-            res
-        ) 
-    | C.Sort _
-    | C.Implicit as t -> t,metasenv
-    | C.Cast (te,ty) ->
-       let te',metasenv' = um_aux metasenv te in
-       let ty',metasenv'' = um_aux metasenv' ty in
-       C.Cast (te',ty'),metasenv''
-    | C.Prod (n,s,t) ->
-       let s',metasenv' = um_aux metasenv s in
-       let t',metasenv'' = um_aux metasenv' t in
-       C.Prod (n, s', t'), metasenv''
-    | C.Lambda (n,s,t) ->
-       let s',metasenv' = um_aux metasenv s in
-       let t',metasenv'' = um_aux metasenv' t in
-       C.Lambda (n, s', t'), metasenv''
-    | C.LetIn (n,s,t) ->
-       let s',metasenv' = um_aux metasenv s in
-       let t',metasenv'' = um_aux metasenv' t in
-       C.LetIn (n, s', t'), metasenv''
-    | C.Appl (he::tl) ->
-       let tl',metasenv' =
-        List.fold_right
-	 (fun t (tl,metasenv) ->
-	   let t',metasenv' = um_aux metasenv t in
-	    t'::tl, metasenv'
-	 ) tl ([],metasenv)
-       in
-        begin
-         match um_aux metasenv' he with
-            (C.Appl l, metasenv'') -> C.Appl (l@tl'),metasenv''
-          | (he', metasenv'') -> C.Appl (he'::tl'),metasenv''
-        end
-    | C.Appl _ -> assert false
-    | C.Const _
-    | C.Abst _
-    | C.MutInd _
-    | C.MutConstruct _ as t -> t,metasenv
-    | C.MutCase (sp,cookingsno,i,outty,t,pl) ->
-       let outty',metasenv' = um_aux metasenv outty in
-       let t',metasenv'' = um_aux metasenv' t in
-       let pl',metasenv''' =
-        List.fold_right
-	 (fun p (pl,metasenv) ->
-	   let p',metasenv' = um_aux metasenv p in
-	    p'::pl, metasenv'
-	 ) pl ([],metasenv'')
-       in
-        C.MutCase (sp, cookingsno, i, outty', t', pl'),metasenv'''
-    | C.Fix (i, fl) ->
-       let len = List.length fl in
-       let liftedfl,metasenv' =
-        List.fold_right
-         (fun (name, i, ty, bo) (fl,metasenv) ->
-	   let ty',metasenv' = um_aux metasenv ty in
-	   let bo',metasenv'' = um_aux metasenv' bo in
-	    (name, i, ty', bo')::fl,metasenv''
-	 ) fl ([],metasenv)
-       in
-        C.Fix (i, liftedfl),metasenv'
-    | C.CoFix (i, fl) ->
-       let len = List.length fl in
-       let liftedfl,metasenv' =
-        List.fold_right
-         (fun (name, ty, bo) (fl,metasenv) ->
-	   let ty',metasenv' = um_aux metasenv ty in
-	   let bo',metasenv'' = um_aux metasenv' bo in
-	    (name, ty', bo')::fl,metasenv''
-	 ) fl ([],metasenv)
-       in
-        C.CoFix (i, liftedfl),metasenv'
+and fo_unif_subst test_equality_only subst context metasenv t1 t2 ugraph =  
+ let module C = Cic in
+ let module R = CicReduction in
+ let module S = CicSubstitution in
+ let t1 = deref subst t1 in
+ let t2 = deref subst t2 in
+ let b,ugraph  = 
+let foo () =
+   R.are_convertible ~subst ~metasenv context t1 t2 ugraph 
+in profiler_are_convertible.HExtlib.profile foo ()
  in
-  let t',metasenv' = um_aux metasenv t in
-   t',metasenv',!unwinded 
-;;
-
-(* apply_subst_reducing subst (Some (mtr,reductions_no)) t              *)
-(* performs as (apply_subst subst t) until it finds an application of   *)
-(* (META [meta_to_reduce]) that, once unwinding is performed, creates   *)
-(* a new beta-redex; in this case up to [reductions_no] consecutive     *)
-(* beta-reductions are performed.                                       *)
-(* Hint: this function is usually called when [reductions_no]           *)
-(*  eta-expansions have been performed and the head of the new          *)
-(*  application has been unified with (META [meta_to_reduce]):          *)
-(*  during the unwinding the eta-expansions are undone.                 *)
-
-let apply_subst_reducing subst meta_to_reduce t =
- let unwinded = ref subst in
- let rec um_aux =
-  let module C = Cic in
-  let module S = CicSubstitution in 
-   function
-      C.Rel _
-    | C.Var _  as t -> t
-    | C.Meta (i,l) as t ->
-       (try
-         S.lift_meta l (List.assoc i !unwinded)
-        with Not_found ->
-          C.Meta (i,l))
-    | C.Sort _ as t -> t
-    | C.Implicit as t -> t
-    | C.Cast (te,ty) -> C.Cast (um_aux te, um_aux ty)
-    | C.Prod (n,s,t) -> C.Prod (n, um_aux s, um_aux t)
-    | C.Lambda (n,s,t) -> C.Lambda (n, um_aux s, um_aux t)
-    | C.LetIn (n,s,t) -> C.LetIn (n, um_aux s, um_aux t)
-    | C.Appl (he::tl) ->
-       let tl' = List.map um_aux tl in
-        let t' =
-         match um_aux he with
-            C.Appl l -> C.Appl (l@tl')
-          | _ as he' -> C.Appl (he'::tl')
-        in
+   if b then
+     subst, metasenv, ugraph 
+   else
+   match (t1, t2) with
+     | (C.Meta (n,ln), C.Meta (m,lm)) when n=m ->
+         let _,subst,metasenv,ugraph1 =
+           (try
+              List.fold_left2
+                (fun (j,subst,metasenv,ugraph) t1 t2 ->
+                   match t1,t2 with
+                       None,_
+                     | _,None -> j+1,subst,metasenv,ugraph
+                     | Some t1', Some t2' ->
+                         (* First possibility:  restriction    *)
+                         (* Second possibility: unification    *)
+                         (* Third possibility:  convertibility *)
+                         let b, ugraph1 = 
+                         R.are_convertible 
+                           ~subst ~metasenv context t1' t2' ugraph
+                         in
+                         if b then
+                           j+1,subst,metasenv, ugraph1 
+                         else
+                           (try
+                              let subst,metasenv,ugraph2 =
+                                fo_unif_subst 
+                                  test_equality_only 
+                                  subst context metasenv t1' t2' ugraph
+                              in
+                                j+1,subst,metasenv,ugraph2
+                            with
+                                Uncertain _
+                              | UnificationFailure _ ->
+debug_print (lazy ("restringo Meta n." ^ (string_of_int n) ^ "on variable n." ^ (string_of_int j))); 
+                                  let metasenv, subst = 
+                                    CicMetaSubst.restrict 
+                                      subst [(n,j)] metasenv in
+                                    j+1,subst,metasenv,ugraph1)
+                ) (1,subst,metasenv,ugraph) ln lm
+            with
+                Exit ->
+                  raise 
+                    (UnificationFailure (lazy "1"))
+                    (*
+                    (sprintf
+                      "Error trying to unify %s with %s: the algorithm tried to check whether the two substitutions are convertible; if they are not, it tried to unify the two substitutions. No restriction was attempted."
+                      (CicMetaSubst.ppterm subst t1) 
+                      (CicMetaSubst.ppterm subst t2))) *)
+              | Invalid_argument _ ->
+                  raise 
+                    (UnificationFailure (lazy "2")))
+                    (*
+                    (sprintf
+                      "Error trying to unify %s with %s: the lengths of the two local contexts do not match." 
+                      (CicMetaSubst.ppterm subst t1) 
+                      (CicMetaSubst.ppterm subst t2)))) *)
+         in subst,metasenv,ugraph1
+     | (C.Meta (n,_), C.Meta (m,_)) when n>m ->
+         fo_unif_subst test_equality_only subst context metasenv t2 t1 ugraph
+     | (C.Meta (n,l), t)   
+     | (t, C.Meta (n,l)) ->
+         let swap =
+           match t1,t2 with
+               C.Meta (n,_), C.Meta (m,_) when n < m -> false
+             | _, C.Meta _ -> false
+             | _,_ -> true
+         in
+         let lower = fun x y -> if swap then y else x in
+         let upper = fun x y -> if swap then x else y in
+         let fo_unif_subst_ordered 
+             test_equality_only subst context metasenv m1 m2 ugraph =
+           fo_unif_subst test_equality_only subst context metasenv 
+             (lower m1 m2) (upper m1 m2) ugraph
+         in
          begin
-          match meta_to_reduce,he with
-             Some (mtr,reductions_no), C.Meta (m,_) when m = mtr ->
-              let rec beta_reduce =
-               function
-                  (n,(C.Appl (C.Lambda (_,_,t)::he'::tl'))) when n > 0 ->
-                    let he'' = CicSubstitution.subst he' t in
-                     if tl' = [] then
-                      he''
-                     else
-                      beta_reduce (n-1,C.Appl(he''::tl'))
-                | (_,t) -> t
+         let subst,metasenv,ugraph1 =
+           let (_,_,meta_type) =  CicUtil.lookup_meta n metasenv in
+           (try
+              let tyt,ugraph1 = 
+                type_of_aux' metasenv subst context t ugraph 
               in
-               beta_reduce (reductions_no,t')
-           | _,_ -> t'
+                fo_unif_subst 
+                  test_equality_only 
+                  subst context metasenv tyt (S.subst_meta l meta_type) ugraph1
+            with 
+                UnificationFailure _ as e -> raise e
+              | Uncertain msg -> raise (UnificationFailure msg)
+              | AssertFailure _ ->
+                  debug_print (lazy "siamo allo huge hack");
+                  (* TODO huge hack!!!!
+                   * we keep on unifying/refining in the hope that 
+                   * the problem will be eventually solved. 
+                   * In the meantime we're breaking a big invariant:
+                   * the terms that we are unifying are no longer well 
+                   * typed in the current context (in the worst case 
+                   * we could even diverge) *)
+                  (subst, metasenv,ugraph)) in
+         let t',metasenv,subst =
+           try 
+             CicMetaSubst.delift n subst context metasenv l t
+           with
+               (CicMetaSubst.MetaSubstFailure msg)-> 
+                 raise (UnificationFailure msg)
+             | (CicMetaSubst.Uncertain msg) -> raise (Uncertain msg)
+         in
+         let t'',ugraph2 =
+           match t' with
+               C.Sort (C.Type u) when not test_equality_only ->
+                 let u' = CicUniv.fresh () in
+                 let s = C.Sort (C.Type u') in
+                 let ugraph2 =   
+                   CicUniv.add_ge (upper u u') (lower u u') ugraph1
+                 in
+                   s,ugraph2
+             | _ -> t',ugraph1
+         in
+         (* Unifying the types may have already instantiated n. Let's check *)
+         try
+           let (_, oldt,_) = CicUtil.lookup_subst n subst in
+           let lifted_oldt = S.subst_meta l oldt in
+             fo_unif_subst_ordered 
+               test_equality_only subst context metasenv t lifted_oldt ugraph2
+         with
+             CicUtil.Subst_not_found _ -> 
+               let (_, context, ty) = CicUtil.lookup_meta n metasenv in
+               let subst = (n, (context, t'',ty)) :: subst in
+               let metasenv =
+                 List.filter (fun (m,_,_) -> not (n = m)) metasenv in
+               subst, metasenv, ugraph2
          end
-    | C.Appl _ -> assert false
-    | C.Const _ as t -> t
-    | C.Abst _  as t -> t
-    | C.MutInd _ as t -> t
-    | C.MutConstruct _ as t -> t
-    | C.MutCase (sp,cookingsno,i,outty,t,pl) ->
-       C.MutCase (sp, cookingsno, i, um_aux outty, um_aux t,
-        List.map um_aux pl)
-    | C.Fix (i, fl) ->
-       let len = List.length fl in
-       let liftedfl =
-        List.map
-         (fun (name, i, ty, bo) -> (name, i, um_aux ty, um_aux bo))
-          fl
+   | (C.Var (uri1,exp_named_subst1),C.Var (uri2,exp_named_subst2))
+   | (C.Const (uri1,exp_named_subst1),C.Const (uri2,exp_named_subst2)) ->
+      if UriManager.eq uri1 uri2 then
+       fo_unif_subst_exp_named_subst test_equality_only subst context metasenv
+        exp_named_subst1 exp_named_subst2 ugraph
+      else
+       raise (UnificationFailure (lazy 
+          (sprintf
+            "Can't unify %s with %s due to different constants"
+            (CicMetaSubst.ppterm subst t1) 
+            (CicMetaSubst.ppterm subst t2)))) 
+   | C.MutInd (uri1,i1,exp_named_subst1),C.MutInd (uri2,i2,exp_named_subst2) ->
+       if UriManager.eq uri1 uri2 && i1 = i2 then
+         fo_unif_subst_exp_named_subst 
+           test_equality_only 
+           subst context metasenv exp_named_subst1 exp_named_subst2 ugraph
+       else
+         raise (UnificationFailure (lazy "4"))
+           (* (sprintf
+              "Can't unify %s with %s due to different inductive principles"
+              (CicMetaSubst.ppterm subst t1) 
+              (CicMetaSubst.ppterm subst t2))) *)
+   | C.MutConstruct (uri1,i1,j1,exp_named_subst1),
+       C.MutConstruct (uri2,i2,j2,exp_named_subst2) ->
+       if UriManager.eq uri1 uri2 && i1 = i2 && j1 = j2 then
+         fo_unif_subst_exp_named_subst
+           test_equality_only 
+           subst context metasenv exp_named_subst1 exp_named_subst2 ugraph
+       else
+         raise (UnificationFailure (lazy "5"))
+           (* (sprintf
+              "Can't unify %s with %s due to different inductive constructors"
+              (CicMetaSubst.ppterm subst t1) 
+              (CicMetaSubst.ppterm subst t2))) *)
+   | (C.Implicit _, _) | (_, C.Implicit _) ->  assert false
+   | (C.Cast (te,ty), t2) -> fo_unif_subst test_equality_only 
+                              subst context metasenv te t2 ugraph
+   | (t1, C.Cast (te,ty)) -> fo_unif_subst test_equality_only 
+                              subst context metasenv t1 te ugraph
+   | (C.Prod (n1,s1,t1), C.Prod (_,s2,t2)) -> 
+       let subst',metasenv',ugraph1 = 
+         fo_unif_subst true subst context metasenv s1 s2 ugraph 
        in
-        C.Fix (i, liftedfl)
-    | C.CoFix (i, fl) ->
-       let len = List.length fl in
-       let liftedfl =
-        List.map
-         (fun (name, ty, bo) -> (name, um_aux ty, um_aux bo))
-          fl
+         fo_unif_subst test_equality_only 
+           subst' ((Some (n1,(C.Decl s1)))::context) metasenv' t1 t2 ugraph1
+   | (C.Lambda (n1,s1,t1), C.Lambda (_,s2,t2)) -> 
+       let subst',metasenv',ugraph1 = 
+         fo_unif_subst test_equality_only subst context metasenv s1 s2 ugraph 
        in
-        C.CoFix (i, liftedfl)
- in
-   um_aux t
-;;
-
-(* UNWIND THE MGU INSIDE THE MGU *)
-let unwind_subst metasenv subst =
- let identity_relocation_list_for_metavariable i =
-  let (_,canonical_context,_) =
-   List.find (function (m,_,_) -> m=i) metasenv
-  in
-   let canonical_context_length = List.length canonical_context in
-    let rec aux =
-     function
-        n when n > canonical_context_length -> []
-      | n -> (Some (Cic.Rel n))::(aux (n+1))
-    in
-     aux 1
- in
-  List.fold_left
-   (fun (unwinded,metasenv) (i,_) ->
-     let identity_relocation_list =
-      identity_relocation_list_for_metavariable i
-     in
-      let (_,metasenv',subst') =
-       unwind metasenv subst unwinded (Cic.Meta (i,identity_relocation_list))
-      in
-       subst',metasenv'
-   ) ([],metasenv) subst
-;;
+         fo_unif_subst test_equality_only 
+           subst' ((Some (n1,(C.Decl s1)))::context) metasenv' t1 t2 ugraph1
+   | (C.LetIn (_,s1,t1), t2)  
+   | (t2, C.LetIn (_,s1,t1)) -> 
+       fo_unif_subst 
+        test_equality_only subst context metasenv t2 (S.subst s1 t1) ugraph
+   | (C.Appl l1, C.Appl l2) -> 
+       (* andrea: this case should be probably rewritten in the 
+          spirit of deref *)
+       (match l1,l2 with
+          | C.Meta (i,_)::args1, C.Meta (j,_)::args2 when i = j ->
+              (try 
+                 List.fold_left2 
+                   (fun (subst,metasenv,ugraph) t1 t2 ->
+                      fo_unif_subst 
+                        test_equality_only subst context metasenv t1 t2 ugraph)
+                   (subst,metasenv,ugraph) l1 l2 
+               with (Invalid_argument msg) -> 
+                 raise (UnificationFailure (lazy msg)))
+          | C.Meta (i,l)::args, _ when not(exists_a_meta args) ->
+              (* we verify that none of the args is a Meta, 
+                since beta expanding with respoect to a metavariable 
+                makes no sense  *)
+ (*
+              (try 
+                 let (_,t,_) = CicUtil.lookup_subst i subst in
+                 let lifted = S.subst_meta l t in
+                 let reduced = CicReduction.head_beta_reduce (Cic.Appl (lifted::args)) in
+                   fo_unif_subst 
+                    test_equality_only 
+                     subst context metasenv reduced t2 ugraph
+               with CicUtil.Subst_not_found _ -> *)
+              let subst,metasenv,beta_expanded,ugraph1 =
+                beta_expand_many 
+                  test_equality_only metasenv subst context t2 args ugraph 
+              in
+                fo_unif_subst test_equality_only subst context metasenv 
+                  (C.Meta (i,l)) beta_expanded ugraph1
+          | _, C.Meta (i,l)::args when not(exists_a_meta args)  ->
+              (* (try 
+                 let (_,t,_) = CicUtil.lookup_subst i subst in
+                 let lifted = S.subst_meta l t in
+                 let reduced = CicReduction.head_beta_reduce (Cic.Appl (lifted::args)) in
+                   fo_unif_subst 
+                     test_equality_only 
+                     subst context metasenv t1 reduced ugraph
+               with CicUtil.Subst_not_found _ -> *)
+                 let subst,metasenv,beta_expanded,ugraph1 =
+                   beta_expand_many 
+                     test_equality_only 
+                     metasenv subst context t1 args ugraph 
+                 in
+                   fo_unif_subst test_equality_only subst context metasenv 
+                     (C.Meta (i,l)) beta_expanded ugraph1
+          | _,_ ->
+              let lr1 = List.rev l1 in
+              let lr2 = List.rev l2 in
+              let rec 
+                  fo_unif_l test_equality_only subst metasenv (l1,l2) ugraph =
+                match (l1,l2) with
+                    [],_
+                  | _,[] -> assert false
+                  | ([h1],[h2]) ->
+                      fo_unif_subst 
+                        test_equality_only subst context metasenv h1 h2 ugraph
+                  | ([h],l) 
+                  | (l,[h]) ->
+                      fo_unif_subst test_equality_only subst context metasenv
+                        h (C.Appl (List.rev l)) ugraph
+                  | ((h1::l1),(h2::l2)) -> 
+                      let subst', metasenv',ugraph1 = 
+                        fo_unif_subst 
+                          test_equality_only 
+                          subst context metasenv h1 h2 ugraph
+                      in 
+                        fo_unif_l 
+                          test_equality_only subst' metasenv' (l1,l2) ugraph1
+              in
+                fo_unif_l 
+                  test_equality_only subst metasenv (lr1, lr2)  ugraph)
+   | (C.MutCase (_,_,outt1,t1',pl1), C.MutCase (_,_,outt2,t2',pl2))->
+       let subst', metasenv',ugraph1 = 
+        fo_unif_subst test_equality_only subst context metasenv outt1 outt2
+          ugraph in
+       let subst'',metasenv'',ugraph2 = 
+        fo_unif_subst test_equality_only subst' context metasenv' t1' t2'
+          ugraph1 in
+       (try
+         List.fold_left2 
+          (fun (subst,metasenv,ugraph) t1 t2 ->
+            fo_unif_subst 
+             test_equality_only subst context metasenv t1 t2 ugraph
+          ) (subst'',metasenv'',ugraph2) pl1 pl2 
+        with
+         Invalid_argument _ ->
+          raise (UnificationFailure (lazy "6.1")))
+           (* (sprintf
+              "Error trying to unify %s with %s: the number of branches is not the same." 
+              (CicMetaSubst.ppterm subst t1) 
+              (CicMetaSubst.ppterm subst t2)))) *)
+   | (C.Rel _, _) | (_,  C.Rel _) ->
+       if t1 = t2 then
+         subst, metasenv,ugraph
+       else
+        raise (UnificationFailure (lazy 
+           (sprintf
+             "Can't unify %s with %s because they are not convertible"
+             (CicMetaSubst.ppterm subst t1) 
+             (CicMetaSubst.ppterm subst t2))))
+   | (C.Appl (C.Meta(i,l)::args),t2) when not(exists_a_meta args) ->
+       let subst,metasenv,beta_expanded,ugraph1 =
+         beta_expand_many 
+           test_equality_only metasenv subst context t2 args ugraph 
+       in
+         fo_unif_subst test_equality_only subst context metasenv 
+           (C.Meta (i,l)) beta_expanded ugraph1
+   | (t1,C.Appl (C.Meta(i,l)::args)) when not(exists_a_meta args) ->
+       let subst,metasenv,beta_expanded,ugraph1 =
+         beta_expand_many 
+           test_equality_only metasenv subst context t1 args ugraph 
+       in
+         fo_unif_subst test_equality_only subst context metasenv 
+           beta_expanded (C.Meta (i,l)) ugraph1
+   | (C.Sort _ ,_) | (_, C.Sort _)
+   | (C.Const _, _) | (_, C.Const _)
+   | (C.MutInd  _, _) | (_, C.MutInd _)
+   | (C.MutConstruct _, _) | (_, C.MutConstruct _)
+   | (C.Fix _, _) | (_, C.Fix _) 
+   | (C.CoFix _, _) | (_, C.CoFix _) -> 
+       if t1 = t2 then
+         subst, metasenv, ugraph
+       else 
+         let b,ugraph1 = 
+           R.are_convertible ~subst ~metasenv context t1 t2 ugraph 
+         in
+           if b then 
+             subst, metasenv, ugraph1
+           else
+             raise
+                (UnificationFailure (lazy (sprintf
+                  "Can't unify %s with %s because they are not convertible"
+                  (CicMetaSubst.ppterm subst t1) 
+                  (CicMetaSubst.ppterm subst t2))))
+   | (C.Prod _, t2) ->
+       let t2' = R.whd ~subst context t2 in
+       (match t2' with
+            C.Prod _ -> 
+              fo_unif_subst test_equality_only 
+                subst context metasenv t1 t2' ugraph         
+          | _ -> raise (UnificationFailure (lazy "8")))
+   | (t1, C.Prod _) ->
+       let t1' = R.whd ~subst context t1 in
+       (match t1' with
+            C.Prod _ -> 
+              fo_unif_subst test_equality_only 
+                subst context metasenv t1' t2 ugraph         
+          | _ -> (* raise (UnificationFailure "9")) *)
+             raise 
+                (UnificationFailure (lazy (sprintf
+                   "Can't unify %s with %s because they are not convertible"
+                   (CicMetaSubst.ppterm subst t1) 
+                   (CicMetaSubst.ppterm subst t2)))))
+   | (_,_) ->
+       raise (UnificationFailure (lazy "10"))
+         (* (sprintf
+            "Can't unify %s with %s because they are not convertible"
+            (CicMetaSubst.ppterm subst t1) 
+            (CicMetaSubst.ppterm subst t2))) *)
 
-let apply_subst subst t = 
- (* metasenv will not be used nor modified. So, let's use a dummy empty one *)
- let metasenv = [] in
-  let (t',_,_) = unwind metasenv [] subst t in
-   t'
-;;
+and fo_unif_subst_exp_named_subst test_equality_only subst context metasenv
+ exp_named_subst1 exp_named_subst2 ugraph
+=
+ try
+  List.fold_left2
+   (fun (subst,metasenv,ugraph) (uri1,t1) (uri2,t2) ->
+     assert (uri1=uri2) ;
+     fo_unif_subst test_equality_only subst context metasenv t1 t2 ugraph
+   ) (subst,metasenv,ugraph) exp_named_subst1 exp_named_subst2
+ with
+  Invalid_argument _ ->
+   let print_ens ens =
+    String.concat " ; "
+     (List.map
+       (fun (uri,t) ->
+         UriManager.string_of_uri uri ^ " := " ^ (CicMetaSubst.ppterm subst t)
+       ) ens) 
+   in
+    raise (UnificationFailure (lazy (sprintf
+     "Error trying to unify the two explicit named substitutions (local contexts) %s and %s: their lengths is different." (print_ens exp_named_subst1) (print_ens exp_named_subst2))))
 
 (* A substitution is a (int * Cic.term) list that associates a               *)
 (* metavariable i with its body.                                             *)
@@ -608,12 +688,61 @@ let apply_subst subst t =
 (* a new substitution which is already unwinded and ready to be applied and  *)
 (* a new metasenv in which some hypothesis in the contexts of the            *)
 (* metavariables may have been restricted.                                   *)
-let fo_unif metasenv context t1 t2 =
-prerr_endline "INIZIO FASE 1" ; flush stderr ;
- let subst_to_unwind,metasenv' = fo_unif_new metasenv context t1 t2 in
-prerr_endline "FINE FASE 1" ; flush stderr ;
-let res =
-  unwind_subst metasenv' subst_to_unwind
-in
-prerr_endline "FINE FASE 2" ; flush stderr ; res
+let fo_unif metasenv context t1 t2 ugraph = 
+ fo_unif_subst false [] context metasenv t1 t2 ugraph ;;
+
+let enrich_msg msg subst context metasenv t1 t2 ugraph =
+ lazy (
+  if verbose then
+   sprintf "[Verbose] Unification error unifying %s of type %s with %s of type %s in context\n%s\nand metasenv\n%s\nand substitution\n%s\nbecause %s"
+    (CicMetaSubst.ppterm subst t1)
+    (try
+      let ty_t1,_ = type_of_aux' metasenv subst context t1 ugraph in
+      CicPp.ppterm ty_t1
+    with 
+    | UnificationFailure s
+    | Uncertain s
+    | AssertFailure s -> sprintf "MALFORMED(t1): \n<BEGIN>%s\n<END>" (Lazy.force s))
+    (CicMetaSubst.ppterm subst t2)
+    (try
+      let ty_t2,_ = type_of_aux' metasenv subst context t2 ugraph in
+      CicPp.ppterm ty_t2
+    with
+    | UnificationFailure s
+    | Uncertain s
+    | AssertFailure s -> sprintf "MALFORMED(t2): \n<BEGIN>%s\n<END>" (Lazy.force s))
+    (CicMetaSubst.ppcontext subst context)
+    (CicMetaSubst.ppmetasenv subst metasenv)
+    (CicMetaSubst.ppsubst subst) (Lazy.force msg)
+ else
+   sprintf "Unification error unifying %s of type %s with %s of type %s in context\n%s\nand metasenv\n%s\nbecause %s"
+    (CicMetaSubst.ppterm_in_context subst t1 context)
+    (try
+      let ty_t1,_ = type_of_aux' metasenv subst context t1 ugraph in
+      CicMetaSubst.ppterm_in_context subst ty_t1 context
+    with 
+    | UnificationFailure s
+    | Uncertain s
+    | AssertFailure s -> sprintf "MALFORMED(t1): \n<BEGIN>%s\n<END>" (Lazy.force s))
+    (CicMetaSubst.ppterm_in_context subst t2 context)
+    (try
+      let ty_t2,_ = type_of_aux' metasenv subst context t2 ugraph in
+      CicMetaSubst.ppterm_in_context subst ty_t2 context
+    with
+    | UnificationFailure s
+    | Uncertain s
+    | AssertFailure s -> sprintf "MALFORMED(t2): \n<BEGIN>%s\n<END>" (Lazy.force s))
+    (CicMetaSubst.ppcontext subst context)
+    (CicMetaSubst.ppmetasenv subst metasenv)
+    (Lazy.force msg)
+ )
+
+let fo_unif_subst subst context metasenv t1 t2 ugraph =
+  try
+    fo_unif_subst false subst context metasenv t1 t2 ugraph
+  with
+  | AssertFailure msg ->
+     raise (AssertFailure (enrich_msg msg subst context metasenv t1 t2 ugraph))
+  | UnificationFailure msg ->
+     raise (UnificationFailure (enrich_msg msg subst context metasenv t1 t2 ugraph))
 ;;