One of the bug I detected (and commented) in my last commit was not a bug.

[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 ad1b47206b14aa16e4212e0cb7338ba9c326758d..d50818f73461ac6a31717f181177cc4d8b5d40ca 100644 (file)
--- a/helm/ocaml/cic_unification/cicUnification.ml
+++ b/helm/ocaml/cic_unification/cicUnification.ml
@@ -31,9 +31,15 @@ exception OpenTerm;;
 
 (**** DELIFT ****)
 
-(* 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. *)
+(* 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  *)
+(* 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 *)
+(* of alpha convertibility. Our implementation, though, is even weaker than   *)
+(* alpha convertibility, since it replace the term [tk] if and only if [tk]   *)
+(* is a Rel (missing all the other cases). Does this matter in practice?      *)
 
 exception NotInTheList;;
 
@@ -61,6 +67,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
@@ -71,11 +78,17 @@ 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 *)
+             (*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)) ;
              C.Rel ((position (m-k) l) + k)
           | None -> raise RelToHiddenHypothesis)
@@ -143,7 +156,18 @@ let delift context metasenv l t =
         in
          C.CoFix (i, liftedfl)
   in
-    let res = deliftaux 0 t in
+   let res =
+    try
+     deliftaux 0 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  *)
+      (* order (in the sense of alpha-conversion). See comment above  *)
+      (* related to the delift function.                              *)
+prerr_endline "!!!!!!!!!!! First Order UnificationFailed, but maybe it could have been successful even in a first order setting (no conversion, only alpha convertibility)! Please, implement a better delift function !!!!!!!!!!!!!!!!" ;
+      raise UnificationFailed
+   in
     res, restrict !to_be_restricted metasenv
 ;;