- let lifted_cases = List.map2 map2 cases constructors in
- let args = eliminator :: lps @ predicate :: lifted_cases @ rps @ [arg] in
- Some (C.AAppl (id, args))
-with Invalid_argument _ -> failwith "PCn.mk_ind"
-
-let apply_substs substs =
- let length = List.length substs in
- let rec apply_xns k (uri, t) = uri, apply_term k t
- and apply_ms k = function
- | None -> None
- | Some t -> Some (apply_term k t)
- and apply_fix len k (id, name, i, ty, bo) =
- id, name, i, apply_term k ty, apply_term (k + len) bo
- and apply_cofix len k (id, name, ty, bo) =
- id, name, apply_term k ty, apply_term (k + len) bo
- and apply_term k = function
- | C.ASort _ as t -> t
- | C.AImplicit _ as t -> t
- | C.ARel (id, rid, m, b) as t ->
- if m < k || m >= length + k then t
- else lift 1 k (List.nth substs (m - k))
- | C.AConst (id, uri, xnss) -> C.AConst (id, uri, List.map (apply_xns k) xnss)
- | C.AVar (id, uri, xnss) -> C.AVar (id, uri, List.map (apply_xns k) xnss)
- | C.AMutInd (id, uri, tyno, xnss) -> C.AMutInd (id, uri, tyno, List.map (apply_xns k) xnss)
- | C.AMutConstruct (id, uri, tyno, consno, xnss) -> C.AMutConstruct (id, uri,tyno,consno, List.map (apply_xns k) xnss)
- | C.AMeta (id, i, mss) -> C.AMeta(id, i, List.map (apply_ms k) mss)
- | C.AAppl (id, ts) -> C.AAppl (id, List.map (apply_term k) ts)
- | C.ACast (id, te, ty) -> C.ACast (id, apply_term k te, apply_term k ty)
- | C.AMutCase (id, sp, i, outty, t, pl) -> C.AMutCase (id, sp, i, apply_term k outty, apply_term k t, List.map (apply_term k) pl)
- | C.AProd (id, n, s, t) -> C.AProd (id, n, apply_term k s, apply_term (succ k) t)
- | C.ALambda (id, n, s, t) -> C.ALambda (id, n, apply_term k s, apply_term (succ k) t)
- | C.ALetIn (id, n, s, t) -> C.ALetIn (id, n, apply_term k s, apply_term (succ k) t)
- | C.AFix (id, i, fl) -> C.AFix (id, i, List.map (apply_fix (List.length fl) k) fl)
- | C.ACoFix (id, i, fl) -> C.ACoFix (id, i, List.map (apply_cofix (List.length fl) k) fl)
+ let rec gen_fix len k (id, name, i, ty, bo) =
+ id, name, i, gen_term k ty, gen_term (k + len) bo
+ and gen_cofix len k (id, name, ty, bo) =
+ id, name, gen_term k ty, gen_term (k + len) bo
+ and gen_term k = function
+ | C.ASort (id, _)
+ | C.AImplicit (id, _)
+ | C.AConst (id, _, _)
+ | C.AVar (id, _, _)
+ | C.AMutInd (id, _, _, _)
+ | C.AMutConstruct (id, _, _, _, _)
+ | C.AMeta (id, _, _) -> meta id
+ | C.ARel (id, _, m, _) ->
+ if succ (k - n) <= m && m <= k then hole id else meta id
+ | C.AAppl (id, ts) ->
+ let ts = List.map (gen_term k) ts in
+ if is_meta ts then meta id else C.AAppl (id, ts)
+ | C.ACast (id, te, ty) ->
+ let te, ty = gen_term k te, gen_term k ty in
+ if is_meta [te; ty] then meta id else C.ACast (id, te, ty)
+ | C.AMutCase (id, sp, i, outty, t, pl) ->
+ let outty, t, pl = gen_term k outty, gen_term k t, List.map (gen_term k) pl in
+ if is_meta (outty :: t :: pl) then meta id else hole id (* C.AMutCase (id, sp, i, outty, t, pl) *)
+ | C.AProd (id, _, s, t) ->
+ let s, t = gen_term k s, gen_term (succ k) t in
+ if is_meta [s; t] then meta id else C.AProd (id, anon, s, t)
+ | C.ALambda (id, _, s, t) ->
+ let s, t = gen_term k s, gen_term (succ k) t in
+ if is_meta [s; t] then meta id else C.ALambda (id, anon, s, t)
+ | C.ALetIn (id, _, s, ty, t) ->
+ let s, ty, t = gen_term k s, gen_term k ty, gen_term (succ k) t in
+ if is_meta [s; t] then meta id else C.ALetIn (id, anon, s, ty, t)
+ | C.AFix (id, i, fl) -> C.AFix (id, i, List.map (gen_fix (List.length fl) k) fl)
+ | C.ACoFix (id, i, fl) -> C.ACoFix (id, i, List.map (gen_cofix (List.length fl) k) fl)
+ in
+ gen_term 0
+
+let mk_pattern psno predicate =
+ let body = generalize psno predicate in
+ clear_absts 0 psno body
+
+let get_clears c p xtypes =
+ let meta = C.Implicit None in
+ let rec aux c names p it et = function
+ | [] ->
+ List.rev c, List.rev names
+ | Some (C.Name name as n, C.Decl v) as hd :: tl ->
+ let hd, names, v =
+ if DTI.does_not_occur 1 p && DTI.does_not_occur 1 it && DTI.does_not_occur 1 et then
+ Some (C.Anonymous, C.Decl v), name :: names, meta
+ else
+ hd, names, v
+ in
+ let p = C.Lambda (n, v, p) in
+ let it = C.Prod (n, v, it) in
+ let et = C.Prod (n, v, et) in
+ aux (hd :: c) names p it et tl
+ | Some (C.Name name as n, C.Def (v, x)) as hd :: tl ->
+ let hd, names, v =
+ if DTI.does_not_occur 1 p && DTI.does_not_occur 1 it && DTI.does_not_occur 1 et then
+ Some (C.Anonymous, C.Def (v, x)), name :: names, meta
+ else
+ hd, names, v
+ in
+ let p = C.LetIn (n, v, x, p) in
+ let it = C.LetIn (n, v, x, it) in
+ let et = C.LetIn (n, v, x, et) in
+ aux (hd :: c) names p it et tl
+ | Some (C.Anonymous as n, C.Decl v) as hd :: tl ->
+ let p = C.Lambda (n, meta, p) in
+ let it = C.Lambda (n, meta, it) in
+ let et = C.Lambda (n, meta, et) in
+ aux (hd :: c) names p it et tl
+ | Some (C.Anonymous as n, C.Def (v, _)) as hd :: tl ->
+ let p = C.LetIn (n, meta, meta, p) in
+ let it = C.LetIn (n, meta, meta, it) in
+ let et = C.LetIn (n, meta, meta, et) in
+ aux (hd :: c) names p it et tl
+ | None :: tl -> assert false