X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fsoftware%2Fcomponents%2Fng_refiner%2FnCicMetaSubst.ml;h=421194abdb02b3a4431149b995e6b7493e104248;hb=8e0e2b06cfc3fb3116e1fce632d9897fdbac9895;hp=3f2f43df09d30d1449ec0ea2828be8b1276c0c0b;hpb=e898ca2563cc4dfbd328efc7aa3a4ff86feaec92;p=helm.git

diff --git a/helm/software/components/ng_refiner/nCicMetaSubst.ml b/helm/software/components/ng_refiner/nCicMetaSubst.ml
index 3f2f43df0..421194abd 100644
--- a/helm/software/components/ng_refiner/nCicMetaSubst.ml
+++ b/helm/software/components/ng_refiner/nCicMetaSubst.ml
@@ -14,24 +14,27 @@
 exception MetaSubstFailure of string Lazy.t
 exception Uncertain of string Lazy.t
 
-let newmeta = 
+let newmeta,maxmeta = 
   let maxmeta = ref 0 in
-  fun () -> incr maxmeta; !maxmeta
+  (fun () -> incr maxmeta; !maxmeta),
+  (fun () -> !maxmeta)
 ;;
 
 exception NotInTheList;;
 
-let position n (shift, lc) =
+let position to_skip n (shift, lc) =
   match lc with
+  | NCic.Irl _ when to_skip > 0 -> assert false  (* unclear to me *)
   | NCic.Irl len when n <= shift || n > shift + len -> raise NotInTheList
   | NCic.Irl _ -> n - shift
   | NCic.Ctx tl ->
-      let rec aux k = function 
+      let rec aux to_skip k = function 
          | [] -> raise NotInTheList
+         | _ :: tl when to_skip > 0 -> aux (to_skip - 1) (k+1) tl
          | (NCic.Rel m)::_ when m + shift = n -> k
-         | _::tl -> aux (k+1) tl 
+         | _::tl -> aux to_skip (k+1) tl 
       in
-       aux 1 tl
+       aux to_skip 1 tl
 ;;
 
 let pack_lc orig = 
@@ -69,31 +72,41 @@ let rec force_does_not_occur metasenv subst restrictions t =
         in
         if amount > 0 then ms, NCic.Rel (r - amount) else ms, orig
     | NCic.Meta (n, (shift,lc as l)) as orig ->
-       (* we ignore the subst since restrict will take care of already
-        * instantiated/restricted metavariabels *)
-       let (metasenv,subst as ms), restrictions_for_n, l' =
-         let l = NCicUtils.expand_local_context lc in
-
-         let ms, _, restrictions_for_n, l =
-          List.fold_right
-            (fun t (ms, i, restrictions_for_n, l) ->
-              try 
-                let ms, t = aux (k-shift) ms t in
-                ms, i-1, restrictions_for_n, t::l
-              with Occur ->
-                ms, i-1, i::restrictions_for_n, l)
-            l (ms, List.length l, [], [])
-         in
-             
-          ms, restrictions_for_n, pack_lc (shift, NCic.Ctx l)
+       let meta_chain =
+        try
+         Some (NCicUtils.lookup_subst n subst)
+        with
+         NCicUtils.Subst_not_found _ -> None
        in
-       if restrictions_for_n = [] then
-         ms, if l = l' then orig else NCic.Meta (n, l')
-       else
-         let metasenv, subst, newmeta = 
-           restrict metasenv subst n restrictions_for_n 
-         in
-           (metasenv, subst), NCic.Meta (newmeta, l')
+        (match meta_chain with
+            Some (_,_,bo,_) ->
+             aux k ms (NCicSubstitution.subst_meta l bo)
+          | None ->
+             (* we ignore the subst since restrict will take care of already
+              * instantiated/restricted metavariabels *)
+             let (metasenv,subst as ms), restrictions_for_n, l' =
+               let l = NCicUtils.expand_local_context lc in
+         
+               let ms, _, restrictions_for_n, l =
+                List.fold_right
+                  (fun t (ms, i, restrictions_for_n, l) ->
+                    try 
+                      let ms, t = aux (k-shift) ms t in
+                      ms, i-1, restrictions_for_n, t::l
+                    with Occur ->
+                      ms, i-1, i::restrictions_for_n, l)
+                  l (ms, List.length l, [], [])
+               in
+                   
+                ms, restrictions_for_n, pack_lc (shift, NCic.Ctx l)
+             in
+             if restrictions_for_n = [] then
+               ms, if l = l' then orig else NCic.Meta (n, l')
+             else
+               let metasenv, subst, newmeta = 
+                 restrict metasenv subst n restrictions_for_n 
+               in
+                 (metasenv, subst), NCic.Meta (newmeta, l'))
     | t -> NCicUntrusted.map_term_fold_a (fun _ k -> k+1) k aux ms t
  in
    aux 0 (metasenv,subst) t 
@@ -193,23 +206,111 @@ and restrict metasenv subst i restrictions =
     | NCicUtils.Meta_not_found _ -> assert false
 ;;
 
+let rec flexible_arg context subst = function 
+  | NCic.Meta (i,_) ->
+      (try 
+        let _,_,t,_ = List.assoc i subst in
+        flexible_arg context subst t
+      with Not_found -> true)
+  | NCic.Appl (NCic.Meta (i,_) :: args)-> 
+      (try 
+        let _,_,t,_ = List.assoc i subst in
+        flexible_arg context subst 
+          (NCicReduction.head_beta_reduce ~delta:max_int 
+            (NCic.Appl (t :: args)))
+      with Not_found -> true)
+   (* this is a cheap whd, it only performs zeta-reduction.
+    * 
+    * it works when the **omissis** disambiguation algorithm
+    * is run on `let x := K a b in t`, K is substituted for a 
+    * ? and thus in t metavariables have a flexible Rel
+    *)
+  | NCic.Rel i ->
+      (try
+         match List.nth context (i-1)
+         with 
+         | _,NCic.Def (bo,_) ->
+               flexible_arg context subst
+                 (NCicSubstitution.lift i bo)
+         | _ -> false
+      with 
+      | Failure _ -> 
+          prerr_endline (Printf.sprintf "Rel %d inside context:\n%s" i  
+            (NCicPp.ppcontext ~subst ~metasenv:[] context));
+          assert false
+      | Invalid_argument _ -> assert false)
+  | _ -> false
+;;
+
+let is_out_scope = function `OutScope _ -> true | _ -> false;;
+let is_out_scope_tag = List.exists is_out_scope;;
+let int_of_out_scope_tag tag = 
+ match List.filter is_out_scope tag with [`OutScope n] -> n | _ -> assert false
+;;
+
+
+exception Found;;
+
 (* INVARIANT: we suppose that t is not another occurrence of Meta(n,_), 
    otherwise the occur check does not make sense in case of unification
    of ?n with ?n *)
-let delift metasenv subst context n l t =
-  let rec aux k (metasenv, subst as ms) = function
+let delift ~unify metasenv subst context n l t =
+  let is_in_scope_meta subst = function
+    | NCic.Meta (i,_) ->
+        (try 
+           let tag, _, _, _ = NCicUtils.lookup_subst i subst in 
+            List.mem `InScope tag
+        with NCicUtils.Subst_not_found _ -> false)
+    | _ -> false
+  in
+  let contains_in_scope subst t = 
+    let rec aux _ () = function
+      | NCic.Meta _ as t ->
+          if is_in_scope_meta subst t then raise Found
+          else ()
+      | t -> 
+          if is_in_scope_meta subst t then raise Found
+          else NCicUtils.fold (fun _ () -> ()) () aux () t
+    in
+    try aux () () t; false with Found -> true
+  in
+  let unify_list in_scope = 
+    match l with
+    | _, NCic.Irl _ -> fun _ _ _ _ _ -> None
+    | shift, NCic.Ctx l -> fun metasenv subst context k t ->
+       if flexible_arg context subst t || contains_in_scope subst t then None else
+         let lb = 
+           List.map (fun t -> 
+            let t = NCicSubstitution.lift (k+shift) t in
+            t, flexible_arg context subst t) 
+           l 
+         in
+         HExtlib.list_findopt
+          (fun (li,flexible) i ->
+            if flexible || i < in_scope then None else
+             match unify metasenv subst context li t with
+             | Some (metasenv,subst) -> 
+                 Some ((metasenv, subst), NCic.Rel (i+1+k))
+             | None -> None)
+          lb
+  in
+  let rec aux (context,k,in_scope) (metasenv, subst as ms) t = 
+   match unify_list in_scope metasenv subst context k t with
+   | Some x -> x
+   | None -> 
+    match t with 
     | NCic.Rel n as t when n <= k -> ms, t
     | NCic.Rel n -> 
         (try
-          match List.nth context (n-k-1) with
+          match List.nth context (n-1) with
           | _,NCic.Def (bo,_) -> 
-                (try ms, NCic.Rel ((position (n-k) l) + k)
+                (try ms, NCic.Rel ((position in_scope (n-k) l) + k)
                  with NotInTheList ->
                 (* CSC: This bit of reduction hurts performances since it is
                  * possible to  have an exponential explosion of the size of the
                  * proof. required for nat/nth_prime.ma *)
-                  aux k ms (NCicSubstitution.lift n bo))
-          | _,NCic.Decl _ -> ms, NCic.Rel ((position (n-k) l) + k)
+                  aux (context,k,in_scope) ms (NCicSubstitution.lift n bo))
+          | _,NCic.Decl _ -> ms, NCic.Rel ((position in_scope (n-k) l) + k)
         with Failure _ -> assert false) (*Unbound variable found in delift*)
     | NCic.Meta (i,_) when i=n ->
          raise (MetaSubstFailure (lazy (Printf.sprintf (
@@ -219,8 +320,19 @@ let delift metasenv subst context n l t =
             (NCicPp.ppterm ~context ~metasenv ~subst t))))
     | NCic.Meta (i,l1) as orig ->
         (try
-           let _,_,t,_ = NCicUtils.lookup_subst i subst in
-           aux k ms (NCicSubstitution.subst_meta l1 t)
+           let tag,c,t,ty = NCicUtils.lookup_subst i subst in
+           let in_scope, clear = 
+            if List.mem `InScope tag then 0, true
+            else if is_out_scope_tag tag then int_of_out_scope_tag tag,true
+            else in_scope, false
+           in
+           let ms = 
+             if not clear then ms
+             else 
+               metasenv, 
+               (i,([],c,t,ty)) :: List.filter (fun j,_ -> i <> j) subst
+           in
+           aux (context,k,in_scope) ms (NCicSubstitution.subst_meta l1 t)
          with NCicUtils.Subst_not_found _ ->
            if snd l1 = NCic.Irl 0 || snd l1 = NCic.Ctx [] then ms, orig
            else
@@ -289,7 +401,7 @@ let delift metasenv subst context n l t =
                     | t::tl ->
                         let ms, tbr, tl = deliftl tbr (j+1) ms tl in
                         try 
-                          let ms, t = aux k ms t in 
+                          let ms, t = aux (context,k,in_scope) ms t in 
                           ms, tbr, t::tl
                         with
                         | NotInTheList | MetaSubstFailure _ -> ms, j::tbr, tl
@@ -312,9 +424,20 @@ let delift metasenv subst context n l t =
                       restrict metasenv subst i to_be_r in
                     (metasenv, subst), NCic.Meta(newmeta,l1))
 
-    | t -> NCicUntrusted.map_term_fold_a (fun _ k -> k+1) k aux ms t
+    | t -> 
+        NCicUntrusted.map_term_fold_a 
+          (fun e (c,k,s) -> (e::c,k+1,s)) (context,k,in_scope) aux ms t
   in
-   try aux 0 (metasenv,subst) t
+(*
+  prerr_endline (
+    "DELIFTO " ^ NCicPp.ppterm ~metasenv ~subst ~context t ^ " w.r.t. " ^
+    String.concat ", " (List.map (NCicPp.ppterm ~metasenv ~subst ~context) ( 
+      let shift, lc = l in
+      (List.map (NCicSubstitution.lift shift) 
+        (NCicUtils.expand_local_context lc))
+  )));
+*)
+   try aux (context,0,0) (metasenv,subst) t
    with NotInTheList ->
       (* This is the case where we fail even first order unification. *)
       (* The reason is that our delift function is weaker than first  *)
@@ -331,36 +454,33 @@ let delift metasenv subst context n l t =
       let lc = NCicUtils.expand_local_context lc in
       let l = List.map (NCicSubstitution.lift shift) lc in
        if
-         List.exists
-          (fun t -> 
-                  NCicUntrusted.metas_of_term subst context t = [])
-            l
+        List.exists (fun t-> NCicUntrusted.metas_of_term subst context t <> [])l
        then
         raise (Uncertain msg)
        else
         raise (MetaSubstFailure msg)
 ;;
 
-let mk_meta ?name metasenv context ty = 
-  let tyof = function Some s -> Some ("typeof_"^s) | None -> None in
-  let rec mk_meta name n metasenv context = function
+let mk_meta ?(attrs=[]) metasenv context ty = 
+  let tyof = List.map (function `Name s -> `Name ("typeof_"^s) | x -> x) in
+  let rec mk_meta attrs n metasenv context = function
   | `WithType ty ->
     let len = List.length context in
-    let menv_entry = (n, (name, context, ty)) in
+    let menv_entry = (n, (attrs, context, ty)) in
     menv_entry :: metasenv, n, NCic.Meta (n, (0,NCic.Irl len)), ty
   | `Sort ->
     let ty = NCic.Implicit (`Typeof n) in
-    mk_meta (tyof name) n metasenv [] (`WithType ty)
+    mk_meta (`IsSort::tyof attrs) n metasenv [] (`WithType ty)
   | `Type ->
     let metasenv, _, ty, _ = 
-      mk_meta (tyof name) (newmeta ()) metasenv context `Sort in
-    mk_meta name n metasenv context (`WithType ty)
+      mk_meta (tyof attrs) (newmeta ()) metasenv context `Sort in
+    mk_meta attrs n metasenv context (`WithType ty)
   | `Term ->
     let metasenv, _, ty, _ = 
-      mk_meta (tyof name) (newmeta ()) metasenv context `Type in
-    mk_meta name n metasenv context (`WithType ty)
+      mk_meta (tyof attrs) (newmeta ()) metasenv context `Type in
+    mk_meta attrs n metasenv context (`WithType ty)
   in
-    mk_meta name (newmeta ()) metasenv context ty
+    mk_meta attrs (newmeta ()) metasenv context ty
 ;;
 
 let saturate ?(delta=0) metasenv subst context ty goal_arity =
@@ -368,7 +488,7 @@ let saturate ?(delta=0) metasenv subst context ty goal_arity =
   let rec aux metasenv = function
    | NCic.Prod (name,s,t) as ty ->
        let metasenv1, _, arg,_ = 
-          mk_meta ~name:name metasenv context (`WithType s) in            
+          mk_meta ~attrs:[`Name name] metasenv context (`WithType s) in
        let t, metasenv1, args, pno = 
            aux metasenv1 (NCicSubstitution.subst arg t) 
        in