" with " ^ NCicPp.ppterm ~metasenv ~subst ~context t2))
;;
-let unify metasenv subst context t1 t2 =
- (* are_convertible?? *)
+let mk_appl hd tl =
+ match hd with
+ | NCic.Appl l -> NCic.Appl (l@tl)
+ | _ -> NCic.Appl (hd :: tl)
+;;
+
+let flexible l =
+ List.exists
+ (function
+ | NCic.Meta _
+ | NCic.Appl (NCic.Meta _::_) -> true
+ | _ -> false) l
+;;
+
+exception WrongShape;;
+
+let eta_reduce after_beta_expansion after_beta_expansion_body
+ before_beta_expansion
+ =
+ try
+ match before_beta_expansion,after_beta_expansion_body with
+ | NCic.Appl l1, NCic.Appl l2 ->
+ let rec all_but_last check_last = function
+ | [] -> assert false
+ | [NCic.Rel 1] -> []
+ | [_] -> if check_last then raise WrongShape else []
+ | he::tl -> he::(all_but_last check_last tl)
+ in
+ let all_but_last check_last l =
+ match all_but_last check_last l with
+ | [] -> assert false
+ | [he] -> he
+ | l -> NCic.Appl l
+ in
+ let t =
+ NCicSubstitution.subst (NCic.Sort NCic.Prop) (all_but_last true l2) in
+ let all_but_last = all_but_last false l in
+ if t = all_but_last then all_but_last else after_beta_expansion
+ | _ -> after_beta_expansion
+ with WrongShape -> after_beta_expansion
+;;
+
+let rec beta_expand num test_equality_only metasenv subst context t arg =
+ let rec aux (n,context as k) (metasenv, subst as acc) t' =
+ try
+ let metasenv, subst =
+ unify (* test_equality_only *) metasenv subst context
+ (NCicSubstitution.lift n arg) t'
+ in
+ (metasenv, subst), C.Rel (1 + n)
+ with Uncertain _ | UnificationFailure _ ->
+ match t' with
+ | NCic.Rel m ->
+ (metasenv, subst), if m <= n then NCic.Rel m else NCic.Rel (m+1)
+ (* andrea: in general, beta_expand can create badly typed
+ terms. This happens quite seldom in practice, UNLESS we
+ iterate on the local context. For this reason, we renounce
+ to iterate and just lift *)
+ | NCic.Meta (i,(shift,lc)) ->
+ (metasenv,subst), NCic.Meta (i,(shift+1,lc))
+ | t ->
+ NCicUntrusted.map_term_fold_a
+ (fun e (n,ctx) -> n+i,e::ctx) k aux acc t
+
+ in
+ let argty = NCicTypeChecker.typeof ~metasenv ~subst context arg in
+ let fresh_name = "Hbeta" ^ string_of_int num in
+ let (metasenv,subst), t = aux (0, context) (metasenv, subst) t in
+ let t = eta_reduce (C.Lambda (fresh_name,argty,t)) t t in
+ metasenv, subst, t
+
+and beta_expand_many test_equality_only metasenv subst context t args ugraph =
+ let _, subst, metasenv, hd =
+ List.fold_right
+ (fun arg (num,subst,metasenv,t) ->
+ let subst, metasenv, t =
+ beta_expand num test_equality_only metasenv subst context t arg
+ in
+ num+1,subst,metasenv,t)
+ args (1,subst,metasenv,t)
+ in
+ metasenv, subst, hd
+
+and instantiate test_eq_only metasenv subst context n lc t swap =
+ let unif m s c t1 t2 =
+ if swap then unify m s c t2 t1 else unify m s c t1 t2
+ in
+ let ty_t =
+ try NCicTypeChecker.typeof ~subst ~metasenv context t
+ with NCicTypeChecker.TypeCheckerFailure _ -> assert false
+ in
+ let name, ctx, ty = NCicUtils.lookup_meta n metasenv in
+ let ty = NCicSubstitution.subst_meta lc ty in
+ let metasenv, subst = unify metasenv susbt context ty ty_t in
+ let (metasenv, subst), t =
+ NCicMetaSubst.delift metasenv subst context n lc t
+ in
+ (* Unifying the types may have already instantiated n. *)
+ try
+ let _, _,oldt,_ = CicUtil.lookup_subst n subst in
+ let oldt = NCicSubstitution.subst_meta lc oldt in
+ (* conjecture: always fail --> occur check *)
+ unify test_eq_only metasenv subst context oldt t
+ with CicUtil.Subst_not_found _ ->
+ (* by cumulativity when unify(?,Type_i)
+ * we could ? := Type_j with j <= i... *)
+ let subst = (n, (name, ctx, t, ty)) :: subst in
+ let metasenv =
+ List.filter (fun (m,_) -> not (n = m)) metasenv
+ in
+ subst, metasenv
+
+and unify metasenv subst context t1 t2 =
let rec aux test_eq_only metasenv subst context t1 t2 =
- let fo_unif test_eq_only t1 t2 =
+ let fo_unif test_eq_only metasenv subst t1 t2 =
if t1 === t2 then
metasenv, subst
else
let context = (name1, C.Def (s1,ty1))::context in
aux test_eq_only metasenv subst context t1 t2
- | (C.Meta (n1,(s1, C.Irl _)), C.Meta (n2,(s2, C.Irl _)))
- when n1 = n2 && s1 = s2 -> true
- | (C.Meta (n1,(s1, l1)), C.Meta (n2,(s2, l2))) when n1 = n2 &&
- let l1 = NCicUtils.expand_local_context l1 in
- let l2 = NCicUtils.expand_local_context l2 in
- (try List.for_all2
- (fun t1 t2 -> aux test_eq_only context
- (NCicSubstitution.lift s1 t1)
- (NCicSubstitution.lift s2 t2))
- l1 l2
- with Invalid_argument _ -> assert false) -> true
-
- | C.Meta (n1,l1), _ ->
+ | (C.Meta (n1,(s1,l1 as lc1)),C.Meta (n2,(s2,l2 as lc2))) when n1 = n2 ->
(try
- let _,_,term,_ = NCicUtils.lookup_subst n1 subst in
- let term = NCicSubstitution.subst_meta l1 term in
- aux test_eq_only context term t2
- with NCicUtils.Subst_not_found _ -> false)
- | _, C.Meta (n2,l2) ->
- (try
- let _,_,term,_ = NCicUtils.lookup_subst n2 subst in
- let term = NCicSubstitution.subst_meta l2 term in
- aux test_eq_only context t1 term
- with NCicUtils.Subst_not_found _ -> false)
-
+ let l1 = NCicUtils.expand_local_context l1 in
+ let l2 = NCicUtils.expand_local_context l2 in
+ let metasenv, subst, to_restrict, _ =
+ List.fold_right2
+ (fun t1 t2 (metasenv, subst, to_restrict, i) ->
+ try
+ aux test_eq_only metasenv subst context
+ (NCicSubstitution.lift s1 t1) (NCicSubstitution.lift s2 t2),
+ to_restrict, i-1
+ with UnificationFailure _ | Uncertain _ ->
+ metasenv, subst, i::to_restrict, i-1)
+ l1 l2 (metasenv, subst, [], List.length l1)
+ in
+ let metasenv, subst, _ =
+ NCicMetaSubst.restrict metasenv subst n1 to_restrict
+ in
+ metasenv, subst
+ with
+ | Invalid_argument _ -> assert false
+ | NCicMetaSubst.MetaSubstFailure msg ->
+ try
+ let _,_,term,_ = NCicUtils.lookup_subst n1 subst in
+ let term1 = NCicSubstitution.subst_meta lc1 term in
+ let term2 = NCicSubstitution.subst_meta lc2 term in
+ aux test_eq_only metasenv subst context term1 term2
+ with NCicUtils.Subst_not_found _-> raise (UnificationFailure msg))
+
+ | C.Meta (n,lc), t ->
+ try
+ let _,_,term,_ = NCicUtils.lookup_subst n subst in
+ let term = NCicSubstitution.subst_meta lc term in
+ aux test_eq_only metasenv subst context term t
+ with NCicUtils.Subst_not_found _->
+ instantiate test_eq_only metasenv subst context n lc t false
+
+ | t, C.Meta (n,lc) ->
+ try
+ let _,_,term,_ = NCicUtils.lookup_subst n subst in
+ let term = NCicSubstitution.subst_meta lc term in
+ aux test_eq_only metasenv subst context t term
+ with NCicUtils.Subst_not_found _->
+ instantiate test_eq_only metasenv subst context n lc t true
+
+ | NCic.Appl (NCic.Meta (i,l)::args), _ when List.mem_assoc i subst ->
+ let _,_,term,_ = NCicUtils.lookup_subst i subst in
+ let term = NCicSubstitution.subst_meta l term in
+ aux test_eq_only metasenv subst context (mk_appl term args) t2
+
+ | _, NCic.Appl (NCic.Meta (i,l)::args) when List.mem_assoc i subst ->
+ let _,_,term,_ = NCicUtils.lookup_subst i subst in
+ let term = NCicSubstitution.subst_meta l term in
+ aux test_eq_only metasenv subst context t1 (mk_appl term args)
+
+ | NCic.Appl (NCic.Meta (i,_)::_ as l1),
+ NCic.Appl (NCic.Meta (j,_)::_ as l2) when i=j ->
+ try
+ List.fold_left2
+ (fun (metasenv, subst) t1 t2 ->
+ aux test_eq_only metasenv subst context t1 t2)
+ (metasenv,subst) l1 l2
+ with Invalid_argument _ ->
+ raise (fail_exc metasenv subst context t1 t2)
+
+ | NCic.Appl (NCic.Meta (i,l)::args), _ when not (flexible args) ->
+ (* we verify that none of the args is a Meta,
+ since beta expanding w.r.t a metavariable makes no sense *)
+ let subst, metasenv, beta_expanded =
+ beta_expand_many
+ test_equality_only metasenv subst context t2 args ugraph
+ in
+ aux test_eq_only metasenv subst context
+ (C.Meta (i,l)) beta_expanded
+ | _, NCic.Appl (NCic.Meta (i,l)::args) when not(flexible args) ->
+ let subst,metasenv,beta_expanded =
+ beta_expand_many
+ test_equality_only
+ metasenv subst context t1 args ugraph
+ in
+ fo_unif_subst test_equality_only subst context metasenv
+ (C.Meta (i,l)) beta_expanded ugraph1
+ | _,_ ->
+.......
| (C.Appl ((C.Const r1) as _hd1::tl1), C.Appl (C.Const r2::tl2))
when (Ref.eq r1 r2 &&
List.length (E.get_relevance r1) >= List.length tl1) ->
let is_prop =
match remove_prods ~subst [] ty with
| C.Sort C.Prop -> true
+ | _ -> false
+ in
let rec remove_prods ~subst context ty =
let ty = whd ~subst context ty in
match ty with
| (C.Implicit _, _) | (_, C.Implicit _) -> assert false
| _ -> raise (uncert_exc metasenv subst context t1 t2)
in
- let unif_machines ...
-
- in
- try fo_unif
- with Uncertain msg as exn ->
- try unif_machines
- with
- | UnificationFailure _ -> raise (UnificationFailure msg)
- | Uncertain _ -> raise exn
- in
- aux false metasenv subst context t1 t2
-
-let are_convertible ?(subst=[]) get_relevance =
- let rec aux test_eq_only metasenv subst context t1 t2 =
- in
- if alpha_eq test_eq_only t1 t2 then
- true
- else
+ let rec unif_machines metasenv subst = function
+ | ((k1,e1,NCic.Meta _ as t1,s1 as m1),(k2,e2,t2,s2 as m2),delta)
+ | ((k1,e1,t1,s1 as m1),(k2,e2,NCic.Meta _ as t2,s2 as m2),delta) ->
+ try
+ fo_unif test_eq_only metasenv subst (R.unwind m1) (R.unwind m2)
+ with UnificationFailure _ | Uncertain _ when delta > 0 ->
+ let delta = delta - 1 in
+ let red = R.reduce ~delta ~subst context in
+ unif_machines metasenv subst (red m1,red m2,delta)
+ | ((k1,e1,t1,s1 as m1),(k2,e2,t2,s2 as m2),delta) ->
+ try
+ let metasenv, subst =
+ fo_unif test_eq_only metasenv subst
+ (R.unwind (k1,e1,t1,[])) (R.unwind (k2,e2,t2,[]))
+ in
+ let relevance =
+ match t1 with
+ | C.Const r -> NCicEnvironment.get_relevance r
+ | _ -> [] in
+ try
+ let rec check_stack f l1 l2 r a =
+ match l1,l2,r with
+ | x1::tl1, x2::tl2, r::tr ->
+ check_stack f tl1 tl2 tr (f x1 x2 r a)
+ | x1::tl1, x2::tl2, [] ->
+ check_stack f tl1 tl2 tr (f x1 x2 true a)
+ | [], [], _ -> a
+ | _ -> raise (Invalid_argument "check_stack")
+ in
+ check_stack
+ (fun t1 t2 b (metasenv,subst) ->
+ try
+ let t1 = RS.from_stack t1 in
+ let t2 = RS.from_stack t2 in
+ unif_machines metasenv subst (small_delta_step t1 t2)
+ with UnificationFailure _ | Uncertain _ when not b ->
+ metasenv, subst)
+ s1 s2 relevance (metasenv,subst)
+ with Invalid_argument _ ->
+ raise (UnificationFailure (lazy ( "Can't unify " ^ NCicPp.ppterm
+ ~metasenv ~subst ~context (R.unwind m1) ^ " with " ^ NCicPp.ppterm
+ ~metasenv ~subst ~context (R.unwind m2))))
+ with UnificationFailure _ | Uncertain _ when delta > 0 ->
+ let delta = delta - 1 in
+ let red = R.reduce ~delta ~subst context in
+ unif_machines metasenv subst (red m1,red m2,delta)
+ in
let height_of = function
- | C.Const (Ref.Ref (_,Ref.Def h))
- | C.Const (Ref.Ref (_,Ref.Fix (_,_,h)))
- | C.Appl(C.Const(Ref.Ref(_,Ref.Def h))::_)
- | C.Appl(C.Const(Ref.Ref(_,Ref.Fix (_,_,h)))::_) -> h
+ | NCic.Const (Ref.Ref (_,Ref.Def h))
+ | NCic.Const (Ref.Ref (_,Ref.Fix (_,_,h)))
+ | NCic.Appl(NCic.Const(Ref.Ref(_,Ref.Def h))::_)
+ | NCic.Appl(NCic.Const(Ref.Ref(_,Ref.Fix (_,_,h)))::_) -> h
+ | NCic.Meta _ -> max_int
| _ -> 0
in
let small_delta_step (_,_,t1,_ as m1) (_,_,t2,_ as m2) =
R.reduce ~delta ~subst context m2,
delta
in
- let rec convert_machines ((k1,e1,t1,s1 as m1),(k2,e2,t2,s2 as m2),delta) =
- (alpha_eq test_eq_only
- (R.unwind (k1,e1,t1,[])) (R.unwind (k2,e2,t2,[])) &&
- let relevance =
- match t1 with
- C.Const r -> NCicEnvironment.get_relevance r
- | _ -> [] in
- try
- HExtlib.list_forall_default3
- (fun t1 t2 b ->
- not b ||
- let t1 = RS.from_stack t1 in
- let t2 = RS.from_stack t2 in
- convert_machines (small_delta_step t1 t2)) s1 s2 true relevance
- with Invalid_argument _ -> false) ||
- (delta > 0 &&
- let delta = delta - 1 in
- let red = R.reduce ~delta ~subst context in
- convert_machines (red m1,red m2,delta))
- in
- convert_machines (small_delta_step (0,[],t1,[]) (0,[],t2,[]))
+ try fo_unif test_eq_only metasenv subst t1 t2
+ with UnificationFailure msg |Uncertain msg as exn ->
+ try
+ unif_machines metasenv subst
+ (small_delta_step (0,[],t1,[]) (0,[],t2,[]))
+ with
+ | UnificationFailure _ -> raise (UnificationFailure msg)
+ | Uncertain _ -> raise exn
in
- aux false
+ aux false metasenv subst context t1 t2
;;
projects / helm.git / blobdiff