1 (* Copyright (C) 2003-2005, HELM Team.
3 * This file is part of HELM, an Hypertextual, Electronic
4 * Library of Mathematics, developed at the Computer Science
5 * Department, University of Bologna, Italy.
7 * HELM is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
12 * HELM is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with HELM; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
22 * For details, see the HELM World-Wide-Web page,
23 * http://cs.unibo.it/helm/.
27 module E = CicEnvironment
29 module TC = CicTypeChecker
31 module UM = UriManager
32 module Rd = CicReduction
34 module DTI = DoubleTypeInference
36 (* helpers ******************************************************************)
38 let cic = D.deannotate_term
40 let rec list_sub start length = function
41 | _ :: tl when start > 0 -> list_sub (pred start) length tl
42 | hd :: tl when length > 0 -> hd :: list_sub start (pred length) tl
45 (* proof construction *******************************************************)
48 let rec lift_xns k (uri, t) = uri, lift_term k t
49 and lift_ms k = function
51 | Some t -> Some (lift_term k t)
52 and lift_fix len k (id, name, i, ty, bo) =
53 id, name, i, lift_term k ty, lift_term (k + len) bo
54 and lift_cofix len k (id, name, ty, bo) =
55 id, name, lift_term k ty, lift_term (k + len) bo
56 and lift_term k = function
58 | C.AImplicit _ as t -> t
59 | C.ARel (id, rid, m, b) as t ->
61 if m + n > 0 then C.ARel (id, rid, m + n, b) else
63 | C.AConst (id, uri, xnss) -> C.AConst (id, uri, List.map (lift_xns k) xnss)
64 | C.AVar (id, uri, xnss) -> C.AVar (id, uri, List.map (lift_xns k) xnss)
65 | C.AMutInd (id, uri, tyno, xnss) -> C.AMutInd (id, uri, tyno, List.map (lift_xns k) xnss)
66 | C.AMutConstruct (id, uri, tyno, consno, xnss) -> C.AMutConstruct (id, uri,tyno,consno, List.map (lift_xns k) xnss)
67 | C.AMeta (id, i, mss) -> C.AMeta(id, i, List.map (lift_ms k) mss)
68 | C.AAppl (id, ts) -> C.AAppl (id, List.map (lift_term k) ts)
69 | C.ACast (id, te, ty) -> C.ACast (id, lift_term k te, lift_term k ty)
70 | C.AMutCase (id, sp, i, outty, t, pl) -> C.AMutCase (id, sp, i, lift_term k outty, lift_term k t, List.map (lift_term k) pl)
71 | C.AProd (id, n, s, t) -> C.AProd (id, n, lift_term k s, lift_term (succ k) t)
72 | C.ALambda (id, n, s, t) -> C.ALambda (id, n, lift_term k s, lift_term (succ k) t)
73 | C.ALetIn (id, n, s, t) -> C.ALetIn (id, n, lift_term k s, lift_term (succ k) t)
74 | C.AFix (id, i, fl) -> C.AFix (id, i, List.map (lift_fix (List.length fl) k) fl)
75 | C.ACoFix (id, i, fl) -> C.ACoFix (id, i, List.map (lift_cofix (List.length fl) k) fl)
80 let rec aux k n = function
81 | C.AImplicit (_, None) as t -> t
82 | C.ALambda (id, s, v, t) when k > 0 ->
83 C.ALambda (id, s, v, aux (pred k) n t)
84 | C.ALambda (_, _, _, t) when n > 0 ->
85 aux 0 (pred n) (lift 1 (-1) t)
87 Printf.eprintf "CLEAR: %u %s\n" n (CicPp.ppterm (cic t));
93 let hole id = C.AImplicit (id, Some `Hole)
95 let meta id = C.AImplicit (id, None)
97 let anon = C.Anonymous
102 | C.AImplicit (_, None) when b -> b
105 List.fold_left map true
107 let rec gen_fix len k (id, name, i, ty, bo) =
108 id, name, i, gen_term k ty, gen_term (k + len) bo
109 and gen_cofix len k (id, name, ty, bo) =
110 id, name, gen_term k ty, gen_term (k + len) bo
111 and gen_term k = function
113 | C.AImplicit (id, _)
114 | C.AConst (id, _, _)
116 | C.AMutInd (id, _, _, _)
117 | C.AMutConstruct (id, _, _, _, _)
118 | C.AMeta (id, _, _) -> meta id
119 | C.ARel (id, _, m, _) ->
120 if succ (k - n) <= m && m <= k then hole id else meta id
121 | C.AAppl (id, ts) ->
122 let ts = List.map (gen_term k) ts in
123 if is_meta ts then meta id else C.AAppl (id, ts)
124 | C.ACast (id, te, ty) ->
125 let te, ty = gen_term k te, gen_term k ty in
126 if is_meta [te; ty] then meta id else C.ACast (id, te, ty)
127 | C.AMutCase (id, sp, i, outty, t, pl) ->
128 let outty, t, pl = gen_term k outty, gen_term k t, List.map (gen_term k) pl in
129 if is_meta (outty :: t :: pl) then meta id else hole id (* C.AMutCase (id, sp, i, outty, t, pl) *)
130 | C.AProd (id, _, s, t) ->
131 let s, t = gen_term k s, gen_term (succ k) t in
132 if is_meta [s; t] then meta id else C.AProd (id, anon, s, t)
133 | C.ALambda (id, _, s, t) ->
134 let s, t = gen_term k s, gen_term (succ k) t in
135 if is_meta [s; t] then meta id else C.ALambda (id, anon, s, t)
136 | C.ALetIn (id, _, s, t) ->
137 let s, t = gen_term k s, gen_term (succ k) t in
138 if is_meta [s; t] then meta id else C.ALetIn (id, anon, s, t)
139 | C.AFix (id, i, fl) -> C.AFix (id, i, List.map (gen_fix (List.length fl) k) fl)
140 | C.ACoFix (id, i, fl) -> C.ACoFix (id, i, List.map (gen_cofix (List.length fl) k) fl)
144 let mk_pattern psno predicate =
145 let body = generalize psno predicate in
146 clear_absts 0 psno body
148 let get_clears c p xet =
149 let meta = C.Implicit None in
150 let rec aux c names p et = function
152 List.rev c, List.rev names
153 | Some (C.Name name as n, C.Decl v) as hd :: tl ->
155 if DTI.does_not_occur 1 p && DTI.does_not_occur 1 et then
156 Some (C.Anonymous, C.Decl v), name :: names, meta
160 let p = C.Lambda (n, v, p) in
161 let et = C.Prod (n, v, et) in
162 aux (hd :: c) names p et tl
163 | Some (C.Name name as n, C.Def (v, x)) as hd :: tl ->
165 if DTI.does_not_occur 1 p && DTI.does_not_occur 1 et then
166 Some (C.Anonymous, C.Def (v, x)), name :: names, meta
170 let p = C.LetIn (n, v, p) in
171 let et = C.LetIn (n, v, et) in
172 aux (hd :: c) names p et tl
173 | Some (C.Anonymous as n, C.Decl v) as hd :: tl ->
174 let p = C.Lambda (n, meta, p) in
175 let et = C.Lambda (n, meta, et) in
176 aux (hd :: c) names p et tl
177 | Some (C.Anonymous as n, C.Def (v, _)) as hd :: tl ->
178 let p = C.LetIn (n, meta, p) in
179 let et = C.LetIn (n, meta, et) in
180 aux (hd :: c) names p et tl
181 | None :: tl -> assert false
184 | Some et -> aux [] [] p et c
188 let rec aux c = function
190 | Some (C.Name name, entry) :: tail when name = hyp ->
191 aux (Some (C.Anonymous, entry) :: c) tail
192 | entry :: tail -> aux (entry :: c) tail