X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;ds=sidebyside;f=helm%2Focaml%2Fcic_unification%2FcicUnification.ml;h=164a9cdce3bf88b9cb377eecd079bae24dcc04a3;hb=044618edc33fa1cf00ec345e84c2a62939746751;hp=7221dd0a8366f424669ebba5c874dec9c3959bf0;hpb=d28e499e10fda9fca6cd7767822f018aa2d5950d;p=helm.git

diff --git a/helm/ocaml/cic_unification/cicUnification.ml b/helm/ocaml/cic_unification/cicUnification.ml
index 7221dd0a8..164a9cdce 100644
--- a/helm/ocaml/cic_unification/cicUnification.ml
+++ b/helm/ocaml/cic_unification/cicUnification.ml
@@ -33,7 +33,8 @@ exception OpenTerm;;
 
 (* the delift function takes in input an ordered list of optional terms       *)
 (* [t1,...,tn] and a term t, and substitutes every tk = Some (rel(nk)) with   *)
-(* rel(k). Typically, the list of optional terms is the explicit substitution *)(* that is applied to a metavariable occurrence and the result of the delift  *)
+(* rel(k). Typically, the list of optional terms is the explicit substitution *)
+(* that is applied to a metavariable occurrence and the result of the delift  *)
 (* function is a term the implicit variable can be substituted with to make   *)
 (* the term [t] unifiable with the metavariable occurrence.                   *)
 (* In general, the problem is undecidable if we consider equivalence in place *)
@@ -52,6 +53,12 @@ let position n =
   aux 1
 ;;
  
+(*CSC: this restriction function is utterly wrong, since it does not check  *)
+(*CSC: that the variable that is going to be restricted does not occur free *)
+(*CSC: in a part of the sequent that is not going to be restricted.         *)
+(*CSC: In particular, the whole approach is wrong; if restriction can fail  *)
+(*CSC: (as indeed it is the case), we can not collect all the restrictions  *)
+(*CSC: and restrict everything at the end ;-(                               *)
 let restrict to_be_restricted =
   let rec erase i n = 
     function
@@ -67,6 +74,7 @@ let restrict to_be_restricted =
 ;;
 
 
+(*CSC: maybe we should rename delift in abstract, as I did in my dissertation *)
 let delift context metasenv l t =
  let module S = CicSubstitution in
   let to_be_restricted = ref [] in
@@ -77,12 +85,24 @@ let delift context metasenv l t =
          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                 *)
+                    (*CSC: FALSO! La regola per il LetIn non lo fa          *)
          else
           (match List.nth context (m-k-1) with
-            Some (_,C.Def (t,_)) -> deliftaux k (S.lift m t)
+            Some (_,C.Def (t,_)) ->
+             (*CSC: Hmmm. This bit of reduction is not in the spirit of    *)
+             (*CSC: first order unification. Does it help or does it harm? *)
+             deliftaux k (S.lift m t)
           | Some (_,C.Decl t) ->
-             (* It may augment to_be_restricted *)
-             ignore (deliftaux k (S.lift m t)) ;
+             (*CSC: The following check seems to be wrong!             *)
+             (*CSC: B:Set |- ?2 : Set                                  *)
+             (*CSC: A:Set ; x:?2[A/B] |- ?1[x/A] =?= x                 *)
+             (*CSC: Why should I restrict ?2 over B? The instantiation *)
+             (*CSC: ?1 := A is perfectly reasonable and well-typed.    *)
+             (*CSC: Thus I comment out the following two lines that    *)
+             (*CSC: are the incriminated ones.                         *)
+             (*(* It may augment to_be_restricted *)
+               ignore (deliftaux k (S.lift m t)) ;*)
+             (*CSC: end of bug commented out                           *)
              C.Rel ((position (m-k) l) + k)
           | None -> raise RelToHiddenHypothesis)
      | C.Var (uri,exp_named_subst) ->
@@ -479,6 +499,7 @@ let unwind metasenv subst unwinded t =
 (*  during the unwinding the eta-expansions are undone.                 *)
 
 let apply_subst_reducing subst meta_to_reduce t =
+ (* andrea: che senso ha questo ref ?? *)
  let unwinded = ref subst in
  let rec um_aux =
   let module C = Cic in