X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fsoftware%2Fcomponents%2Fng_refiner%2FnCicMetaSubst.ml;h=b18364509db79f282b7d18372bee0d2cd189f87c;hb=ccf5878f2a2ec7f952f140e162391708a740517b;hp=1a2b5471b0cf76910eb0666c1cba0fb96a59b7bb;hpb=d174e54c365ab9df38367de9336c213a03be3c27;p=helm.git

diff --git a/helm/software/components/ng_refiner/nCicMetaSubst.ml b/helm/software/components/ng_refiner/nCicMetaSubst.ml
index 1a2b5471b..b18364509 100644
--- a/helm/software/components/ng_refiner/nCicMetaSubst.ml
+++ b/helm/software/components/ng_refiner/nCicMetaSubst.ml
@@ -11,12 +11,46 @@
 
 (* $Id$ *)
 
+let debug = ref false;;
+let indent = ref "";;
+let times = ref [];;
+let pp s =
+ if !debug then
+  prerr_endline (Printf.sprintf "%-20s" !indent ^ " " ^ Lazy.force s)
+;;
+let inside c =
+ if !debug then
+  begin
+   let time1 = Unix.gettimeofday () in
+   indent := !indent ^ String.make 1 c;
+   times := time1 :: !times;
+   prerr_endline ("{{{" ^ !indent ^ " ")
+  end
+;;
+let outside exc_opt =
+ if !debug then
+  begin
+   let time2 = Unix.gettimeofday () in
+   let time1 =
+    match !times with time1::tl -> times := tl; time1 | [] -> assert false in
+   prerr_endline ("}}} " ^ string_of_float (time2 -. time1));
+   (match exc_opt with
+   | Some e ->  prerr_endline ("exception raised: " ^ Printexc.to_string e)
+   | None -> ());
+   try
+    indent := String.sub !indent 0 (String.length !indent -1)
+   with
+    Invalid_argument _ -> indent := "??"; ()
+  end
+;;
+
 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;;
@@ -62,6 +96,27 @@ let mk_perforated_irl shift len restrictions =
 
 exception Occur;;
 
+let purge_restricted restrictions more_restrictions l =
+ if more_restrictions = [] then l
+ else
+  begin
+   pp (lazy ("TO BE RESTRICTED: " ^ 
+    (String.concat "," (List.map string_of_int restrictions))));
+   pp (lazy ("MORE RESTRICTIONS: " ^ 
+    (String.concat "," (List.map string_of_int more_restrictions))));
+   let shift,lc = l in
+   let lc = NCicUtils.expand_local_context lc in
+    let rec aux n lc =
+     match lc with
+        [] -> []
+      | _ when List.mem n restrictions -> aux (n+1) lc
+      | _::tl when List.mem n more_restrictions -> aux (n+1) tl
+      | he::tl -> he::aux (n+1) tl
+    in
+    pack_lc (shift, NCic.Ctx (aux 1 lc))
+  end
+;;
+
 let rec force_does_not_occur metasenv subst restrictions t =
  let rec aux k ms = function
     | NCic.Rel r when List.mem (r - k) restrictions -> raise Occur
@@ -71,37 +126,50 @@ 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)
-       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')
+       (try
+         let _,_,bo,_ = NCicUtils.lookup_subst n subst in
+          aux k ms (NCicSubstitution.subst_meta l bo)
+        with
+         NCicUtils.Subst_not_found _ ->
+          (* we ignore the subst since restrict will take care of already
+           * instantiated/restricted metavariabels *)
+          let l = NCicUtils.expand_local_context lc in
+          let sl = List.map (NCicSubstitution.lift shift) l in 
+          let (metasenv,subst as ms), _, restrictions_for_n, l' =
+             List.fold_right
+               (fun t (ms, i, restrictions_for_n, l) ->
+                 try 
+              (*pp (lazy ("L'ORLO DELLA FOSSA: k= " ^ string_of_int k ^ " shift=" ^
+               string_of_int shift ^ " t=" ^ NCicPp.ppterm ~metasenv ~subst ~context:[] t));*)
+                   let ms, t = aux k ms t in
+              (*pp (lazy ("LA FOSSA: " ^ NCicPp.ppterm ~metasenv ~subst ~context:[] t));*)
+                   ms, i-1, restrictions_for_n, t::l
+                 with Occur ->
+                   ms, i-1, i::restrictions_for_n, l)
+               sl (ms, List.length l, [], [])
+          in
+          if restrictions_for_n = [] then
+            ms, if sl = l' then orig else (
+                (*pp (lazy ("FINITO: " ^ NCicPp.ppterm ~metasenv:[] ~subst:[]
+                  ~context:[] (NCic.Meta (n,pack_lc (0, NCic.Ctx l')))));*)
+              NCic.Meta (n, pack_lc (0, NCic.Ctx l'))
+            )
+          else
+            let l' = pack_lc (0, NCic.Ctx l') in
+            let _ = pp (lazy ("restrictions for n are:" ^ String.concat "," (List.map string_of_int restrictions_for_n))) in
+            let metasenv, subst, newmeta, more_restricted = 
+              restrict metasenv subst n restrictions_for_n in
+            let _ = pp (lazy ("more restricted: " ^String.concat "," (List.map string_of_int more_restricted))) in
+            let l' = purge_restricted restrictions more_restricted l' 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 
 
 and force_does_not_occur_in_context metasenv subst restrictions = function
   | name, NCic.Decl t as orig ->
+      (* pp (lazy ("CCC: hd is" ^ NCicPp.ppterm ~metasenv:[] ~subst:[] ~context:[] t ^
+      "\nCCC: restrictions are:" ^ String.concat "," (List.map string_of_int restrictions)));*)
       let (metasenv, subst), t' =
         force_does_not_occur metasenv subst restrictions t in
       metasenv, subst, (if t == t' then orig else (name,NCic.Decl t'))
@@ -133,7 +201,7 @@ and erase_in_context metasenv subst pos restrictions = function
         with Occur ->
             metasenv, subst, (pos :: restricted), tl'
 
-and restrict metasenv subst i restrictions =
+and restrict metasenv subst i (restrictions as orig) =
   assert (restrictions <> []);
   try 
     let name, ctx, bo, ty = NCicUtils.lookup_subst i subst in
@@ -152,16 +220,8 @@ and restrict metasenv subst i restrictions =
           subst_entry_j :: List.map 
             (fun (n,_) as orig -> if i = n then subst_entry_i else orig) subst
         in
-(*
-    prerr_endline ("restringo nella subst: " ^string_of_int i ^ " -> " ^ 
-      string_of_int j ^ "\n" ^ 
-      NCicPp.ppsubst ~metasenv [subst_entry_j] ^ "\n\n" ^
-      NCicPp.ppsubst ~metasenv [subst_entry_i] ^ "\n" ^
-      NCicPp.ppterm ~metasenv ~subst ~context:ctx bo ^ " ---- " ^
-      NCicPp.ppterm ~metasenv ~subst ~context:newctx newbo
-            );
-*)
-        metasenv, new_subst, j
+        let diff = List.filter (fun x -> not (List.mem x orig)) restrictions in
+        metasenv, new_subst, j, diff
       with Occur -> raise (MetaSubstFailure (lazy (Printf.sprintf
             ("Cannot restrict the context of the metavariable ?%d over "^^
             "the hypotheses %s since ?%d is already instantiated "^^
@@ -182,10 +242,14 @@ and restrict metasenv subst i restrictions =
         let reloc_irl = 
           mk_perforated_irl 0 (List.length ctx) restrictions in
         let subst_entry = i, (name, ctx, NCic.Meta (j, reloc_irl), ty) in
+         (* pp (lazy ("BBB: dopo1 \n" ^  NCicPp.ppsubst ~metasenv [subst_entry]));
+          pp (lazy ("BBB: dopo2 \n" ^  NCicPp.ppsubst ~metasenv (subst_entry::subst)));
+          pp (lazy ("BBB: dopo metasenv\n" ^  NCicPp.ppmetasenv ~subst [metasenv_entry]));*)
+        let diff = List.filter (fun x -> not (List.mem x orig)) restrictions in
         List.map 
           (fun (n,_) as orig -> if i = n then metasenv_entry else orig) 
           metasenv,
-        subst_entry :: subst, j
+        subst_entry :: subst, j, diff
       with Occur -> raise (MetaSubstFailure (lazy (Printf.sprintf
           ("Cannot restrict the context of the metavariable ?%d "^^
           "over the hypotheses %s since metavariable's type depends "^^
@@ -195,45 +259,89 @@ and restrict metasenv subst i restrictions =
     | NCicUtils.Meta_not_found _ -> assert false
 ;;
 
-let rec flexible_arg subst = function 
-  | NCic.Meta (i,_) | NCic.Appl (NCic.Meta (i,_) :: _)-> 
+let rec is_flexible context ~subst = function 
+  | NCic.Meta (i,_) ->
       (try 
         let _,_,t,_ = List.assoc i subst in
-        flexible_arg subst t
+        is_flexible context ~subst t
       with Not_found -> true)
+  | NCic.Appl (NCic.Meta (i,_) :: args)-> 
+      (try 
+        let _,_,t,_ = List.assoc i subst in
+        is_flexible 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,_) ->
+               is_flexible 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 flexible subst l = List.exists (flexible_arg subst) l;;
-
-let in_scope_tag  = "tag:in_scope" ;;
-let out_scope_tag_prefix = "tag:out_scope:" 
-let out_scope_tag n = out_scope_tag_prefix ^ string_of_int n ;;
-let is_out_scope_tag tag =
-   String.length tag > String.length out_scope_tag_prefix &&
-   String.sub tag 0 (String.length out_scope_tag_prefix) = out_scope_tag_prefix 
-;;
+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 = 
-  int_of_string
-   (String.sub tag (String.length out_scope_tag_prefix)
-     (String.length tag - (String.length out_scope_tag_prefix)))
+ 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 ~unify metasenv subst context n l t =
+  (*D*)  inside 'D'; try let rc =  
+  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 subst t then None else
-         let lb = List.map (fun t -> t, flexible_arg subst t) l in
+       if is_flexible 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, is_flexible context ~subst t) 
+           l 
+         in
          HExtlib.list_findopt
           (fun (li,flexible) i ->
             if flexible || i < in_scope then None else
-             let li = NCicSubstitution.lift (k+shift) li in
              match unify metasenv subst context li t with
              | Some (metasenv,subst) -> 
                  Some ((metasenv, subst), NCic.Rel (i+1+k))
@@ -248,7 +356,7 @@ let delift ~unify metasenv subst context n l t =
     | 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 in_scope (n-k) l) + k)
                  with NotInTheList ->
@@ -266,12 +374,17 @@ let delift ~unify metasenv subst context n l t =
             (NCicPp.ppterm ~context ~metasenv ~subst t))))
     | NCic.Meta (i,l1) as orig ->
         (try
-           let tag,_,t,_ = NCicUtils.lookup_subst i subst in
-           let in_scope = 
-             match tag with 
-             | Some tag when tag = in_scope_tag -> 0
-             | Some tag when is_out_scope_tag tag -> int_of_out_scope_tag tag
-             | _ -> in_scope
+           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 _ ->
@@ -284,11 +397,11 @@ let delift ~unify metasenv subst context n l t =
               | NCic.Irl len, NCic.Irl len1 
                 when shift1 + len1 < shift || shift1 > shift + len ->
                   let restrictions = HExtlib.list_seq 1 (len1 + 1) in
-                  let metasenv, subst, newmeta = 
-                     restrict metasenv subst i restrictions 
-                  in
-                  (metasenv, subst), 
-                    NCic.Meta (newmeta, (0,NCic.Irl (max 0 (k-shift1))))
+                  let metasenv, subst, newmeta, more_restricted = 
+                   restrict metasenv subst i restrictions in
+                  let l' = (0,NCic.Irl (max 0 (k-shift1))) in
+                  let l' = purge_restricted restrictions more_restricted l' in
+                  (metasenv, subst),NCic.Meta (newmeta,l')
               | NCic.Irl len, NCic.Irl len1 ->
                   let low_restrictions, new_shift = 
                     if k <= shift1 && shift1 < shift then 
@@ -312,27 +425,12 @@ let delift ~unify metasenv subst context n l t =
                     if shift = k then ms, orig
                     else ms, NCic.Meta (i, (new_shift, lc1))
                   else
-                    let metasenv, subst, newmeta = 
-                       restrict metasenv subst i restrictions
-                    in
-(* {{{
-                  prerr_endline ("RESTRICTIONS FOR: " ^ 
-                    NCicPp.ppterm ~metasenv ~subst ~context:[] 
-                    (NCic.Meta (i,l1))^" that was part of a term unified with "
-                    ^ NCicPp.ppterm ~metasenv ~subst ~context:[] (NCic.Meta
-                    (n,l)) ^ " ====> " ^ String.concat "," (List.map
-                    string_of_int restrictions) ^ "\nMENV:\n" ^
-                    NCicPp.ppmetasenv ~subst metasenv ^ "\nSUBST:\n" ^
-                    NCicPp.ppsubst subst ~metasenv);
-}}} *)
+                    let metasenv, subst, newmeta, more_restricted = 
+                     restrict metasenv subst i restrictions in
                     let newlc_len = len1 - List.length restrictions in 
-                    let meta = 
-                       NCic.Meta(newmeta,(new_shift, NCic.Irl newlc_len))
-                    in
-                    assert (
-                      let _, cctx, _ = NCicUtils.lookup_meta newmeta metasenv in
-                      List.length cctx = newlc_len);
-                    (metasenv, subst), meta
+                    let l' = new_shift, NCic.Irl newlc_len in
+                    let l' = purge_restricted restrictions more_restricted l' in
+                    (metasenv, subst),NCic.Meta(newmeta,l')
 
               | _ ->
                   let lc1 = NCicUtils.expand_local_context lc1 in
@@ -348,27 +446,34 @@ let delift ~unify metasenv subst context n l t =
                         | NotInTheList | MetaSubstFailure _ -> ms, j::tbr, tl
                   in
                   let (metasenv, subst), to_be_r, lc1' = deliftl [] 1 ms lc1 in
-(*
-                  prerr_endline ("TO BE RESTRICTED: " ^ 
-                   (String.concat "," (List.map string_of_int to_be_r)));
-*)
+                  pp (lazy ("TO BE RESTRICTED: " ^ 
+                   (String.concat "," (List.map string_of_int to_be_r))));
                   let l1 = pack_lc (0, NCic.Ctx lc1') in
-(*
-                  prerr_endline ("newmeta:" ^ NCicPp.ppterm
-                   ~metasenv ~subst ~context (NCic.Meta (999,l1)));
-*)
+                  pp (lazy ("newmeta:" ^ NCicPp.ppterm
+                   ~metasenv ~subst ~context (NCic.Meta (999,l1))));
+                  pp (lazy (NCicPp.ppmetasenv ~subst metasenv));
                   if to_be_r = [] then
                     (metasenv, subst), 
                     (if lc1' = lc1 then orig else NCic.Meta (i,l1))
                   else
-                    let metasenv, subst, newmeta = 
-                      restrict metasenv subst i to_be_r in
-                    (metasenv, subst), NCic.Meta(newmeta,l1))
+                    let metasenv, subst, newmeta, more_restricted = 
+                     restrict metasenv subst i to_be_r in
+                    let l1 = purge_restricted to_be_r more_restricted l1 in
+                     (metasenv, subst), NCic.Meta(newmeta,l1))
 
     | t -> 
         NCicUntrusted.map_term_fold_a 
           (fun e (c,k,s) -> (e::c,k+1,s)) (context,k,in_scope) aux ms t
   in
+(*
+  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. *)
@@ -386,36 +491,39 @@ let delift ~unify 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)
+ (*D*)  in outside None; rc with exn -> outside (Some exn); raise exn 
 ;;
 
-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
-  | `WithType ty ->
-    let len = List.length context in
-    let menv_entry = (n, (name, 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)
-  | `Type ->
-    let metasenv, _, ty, _ = 
-      mk_meta (tyof name) (newmeta ()) metasenv context `Sort in
-    mk_meta name 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)
-  in
-    mk_meta name (newmeta ()) metasenv context ty
+let mk_meta ?(attrs=[]) metasenv context ?with_type kind = 
+  assert(kind <> `IsSort || context = []);
+  let n = newmeta () in
+  let ty= match with_type with None-> NCic.Implicit (`Typeof n)| Some x ->x in
+  let len = List.length context in
+  let attrs = NCicUntrusted.set_kind kind attrs in
+  let menv_entry = (n, (attrs, context, ty)) in
+  menv_entry :: metasenv, n, NCic.Meta (n, (0,NCic.Irl len)), ty
+;;
+
+let extend_meta metasenv n =
+ try
+  let attrs,cc,ty = NCicUtils.lookup_meta n metasenv in 
+  (match ty with 
+  | NCic.Implicit (`Typeof _) -> 
+      let mk_meta context kind =
+        let metasenv, _, ty, _ = mk_meta metasenv context kind in
+        (n, (attrs, cc, ty)) :: List.filter (fun x,_ -> x <> n) metasenv, ty
+      in
+      (match NCicUntrusted.kind_of_meta attrs with
+       | `IsSort 
+       | `IsType -> mk_meta [] `IsSort
+       | `IsTerm -> mk_meta cc `IsType)
+  | ty -> metasenv, ty)
+ with NCicUtils.Meta_not_found _ -> assert false
 ;;
 
 let saturate ?(delta=0) metasenv subst context ty goal_arity =
@@ -423,7 +531,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 ~with_type:s `IsTerm in
        let t, metasenv1, args, pno = 
            aux metasenv1 (NCicSubstitution.subst arg t) 
        in