(* 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 *)
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
(*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) ->
(* 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