First version of refine for MutCase, still largely incomplete.

[helm.git] / helm / ocaml / cic_unification / cicUnification.ml

diff --git a/helm/ocaml/cic_unification/cicUnification.ml b/helm/ocaml/cic_unification/cicUnification.ml
index e0d4d13f233296decf871ab8b05889a598e65773..164a9cdce3bf88b9cb377eecd079bae24dcc04a3 100644 (file)
--- 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
@@ -85,10 +93,16 @@ let delift context metasenv l t =
              (*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 *)
-             (*CSC: Really? Even in the case of well-typed terms?      *)
-             (*CSC: I am no longer sure of the usefulness of the check *)
-             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) ->
@@ -97,9 +111,6 @@ let delift context metasenv l t =
         in
          C.Var (uri,exp_named_subst')
      | C.Meta (i, l1) as t -> 
-(* CSC: BIG BUG HERE! In the explicit substitution l1 = [t1 ; t2],       *)
-(* CSC: it is NOT true that Rel(1) in t2 refers to t1 (i.e. the explicit *)
-(* CSC: substitution is simultaneous, not telescopic. To be fixes ASAP.  *)
         let rec deliftl j =
          function
             [] -> []
@@ -488,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