author | paulson |
Wed, 05 Jun 2002 15:34:55 +0200 | |
changeset 13203 | fac77a839aa2 |
parent 13175 | 81082cfa5618 |
child 13217 | bc5dc2392578 |
permissions | -rw-r--r-- |
13165 | 1 |
(* Title: ZF/WF.thy |
0 | 2 |
ID: $Id$ |
1478 | 3 |
Author: Tobias Nipkow and Lawrence C Paulson |
435 | 4 |
Copyright 1994 University of Cambridge |
0 | 5 |
|
6 |
Well-founded Recursion |
|
13165 | 7 |
|
8 |
Derived first for transitive relations, and finally for arbitrary WF relations |
|
9 |
via wf_trancl and trans_trancl. |
|
10 |
||
11 |
It is difficult to derive this general case directly, using r^+ instead of |
|
12 |
r. In is_recfun, the two occurrences of the relation must have the same |
|
13 |
form. Inserting r^+ in the_recfun or wftrec yields a recursion rule with |
|
14 |
r^+ -`` {a} instead of r-``{a}. This recursion rule is stronger in |
|
15 |
principle, but harder to use, especially to prove wfrec_eclose_eq in |
|
16 |
epsilon.ML. Expanding out the definition of wftrec in wfrec would yield |
|
17 |
a mess. |
|
0 | 18 |
*) |
19 |
||
13165 | 20 |
theory WF = Trancl + mono + equalities: |
21 |
||
22 |
constdefs |
|
23 |
wf :: "i=>o" |
|
24 |
(*r is a well-founded relation*) |
|
25 |
"wf(r) == ALL Z. Z=0 | (EX x:Z. ALL y. <y,x>:r --> ~ y:Z)" |
|
26 |
||
27 |
wf_on :: "[i,i]=>o" ("wf[_]'(_')") |
|
28 |
(*r is well-founded on A*) |
|
29 |
"wf_on(A,r) == wf(r Int A*A)" |
|
30 |
||
31 |
is_recfun :: "[i, i, [i,i]=>i, i] =>o" |
|
32 |
"is_recfun(r,a,H,f) == (f = (lam x: r-``{a}. H(x, restrict(f, r-``{x}))))" |
|
33 |
||
34 |
the_recfun :: "[i, i, [i,i]=>i] =>i" |
|
35 |
"the_recfun(r,a,H) == (THE f. is_recfun(r,a,H,f))" |
|
36 |
||
37 |
wftrec :: "[i, i, [i,i]=>i] =>i" |
|
38 |
"wftrec(r,a,H) == H(a, the_recfun(r,a,H))" |
|
39 |
||
40 |
wfrec :: "[i, i, [i,i]=>i] =>i" |
|
41 |
(*public version. Does not require r to be transitive*) |
|
42 |
"wfrec(r,a,H) == wftrec(r^+, a, %x f. H(x, restrict(f,r-``{x})))" |
|
43 |
||
44 |
wfrec_on :: "[i, i, i, [i,i]=>i] =>i" ("wfrec[_]'(_,_,_')") |
|
45 |
"wfrec[A](r,a,H) == wfrec(r Int A*A, a, H)" |
|
46 |
||
47 |
||
48 |
(*** Well-founded relations ***) |
|
49 |
||
50 |
(** Equivalences between wf and wf_on **) |
|
51 |
||
52 |
lemma wf_imp_wf_on: "wf(r) ==> wf[A](r)" |
|
53 |
apply (unfold wf_def wf_on_def, clarify) (*needed for blast's efficiency*) |
|
54 |
apply blast |
|
55 |
done |
|
56 |
||
57 |
lemma wf_on_field_imp_wf: "wf[field(r)](r) ==> wf(r)" |
|
58 |
by (unfold wf_def wf_on_def, fast) |
|
59 |
||
60 |
lemma wf_iff_wf_on_field: "wf(r) <-> wf[field(r)](r)" |
|
61 |
by (blast intro: wf_imp_wf_on wf_on_field_imp_wf) |
|
62 |
||
63 |
lemma wf_on_subset_A: "[| wf[A](r); B<=A |] ==> wf[B](r)" |
|
64 |
by (unfold wf_on_def wf_def, fast) |
|
65 |
||
66 |
lemma wf_on_subset_r: "[| wf[A](r); s<=r |] ==> wf[A](s)" |
|
67 |
by (unfold wf_on_def wf_def, fast) |
|
68 |
||
69 |
(** Introduction rules for wf_on **) |
|
70 |
||
71 |
lemma wf_onI: |
|
72 |
(*If every non-empty subset of A has an r-minimal element then wf[A](r).*) |
|
73 |
assumes prem: "!!Z u. [| Z<=A; u:Z; ALL x:Z. EX y:Z. <y,x>:r |] ==> False" |
|
74 |
shows "wf[A](r)" |
|
75 |
apply (unfold wf_on_def wf_def) |
|
76 |
apply (rule equals0I [THEN disjCI, THEN allI]) |
|
77 |
apply (rule_tac Z = "Z" in prem, blast+) |
|
78 |
done |
|
79 |
||
80 |
(*If r allows well-founded induction over A then wf[A](r) |
|
81 |
Premise is equivalent to |
|
82 |
!!B. ALL x:A. (ALL y. <y,x>: r --> y:B) --> x:B ==> A<=B *) |
|
83 |
lemma wf_onI2: |
|
84 |
assumes prem: "!!y B. [| ALL x:A. (ALL y:A. <y,x>:r --> y:B) --> x:B; y:A |] |
|
85 |
==> y:B" |
|
86 |
shows "wf[A](r)" |
|
87 |
apply (rule wf_onI) |
|
88 |
apply (rule_tac c=u in prem [THEN DiffE]) |
|
89 |
prefer 3 apply blast |
|
90 |
apply fast+ |
|
91 |
done |
|
92 |
||
93 |
||
94 |
(** Well-founded Induction **) |
|
95 |
||
96 |
(*Consider the least z in domain(r) Un {a} such that P(z) does not hold...*) |
|
97 |
lemma wf_induct: |
|
98 |
"[| wf(r); |
|
99 |
!!x.[| ALL y. <y,x>: r --> P(y) |] ==> P(x) |
|
100 |
|] ==> P(a)" |
|
101 |
apply (unfold wf_def) |
|
102 |
apply (erule_tac x = "{z:domain (r) Un {a}. ~P (z) }" in allE) |
|
103 |
apply blast |
|
104 |
done |
|
435 | 105 |
|
13203
fac77a839aa2
Tidying up. Mainly moving proofs from Main.thy to other (Isar) theory files.
paulson
parents:
13175
diff
changeset
|
106 |
(*fixed up for induct method*) |
fac77a839aa2
Tidying up. Mainly moving proofs from Main.thy to other (Isar) theory files.
paulson
parents:
13175
diff
changeset
|
107 |
lemmas wf_induct = wf_induct [induct set: wf] |
fac77a839aa2
Tidying up. Mainly moving proofs from Main.thy to other (Isar) theory files.
paulson
parents:
13175
diff
changeset
|
108 |
and wf_induct_rule = wf_induct [rule_format, induct set: wf] |
fac77a839aa2
Tidying up. Mainly moving proofs from Main.thy to other (Isar) theory files.
paulson
parents:
13175
diff
changeset
|
109 |
|
13165 | 110 |
(*The form of this rule is designed to match wfI*) |
111 |
lemma wf_induct2: |
|
112 |
"[| wf(r); a:A; field(r)<=A; |
|
113 |
!!x.[| x: A; ALL y. <y,x>: r --> P(y) |] ==> P(x) |] |
|
114 |
==> P(a)" |
|
115 |
apply (erule_tac P="a:A" in rev_mp) |
|
116 |
apply (erule_tac a=a in wf_induct, blast) |
|
117 |
done |
|
118 |
||
119 |
lemma field_Int_square: "field(r Int A*A) <= A" |
|
120 |
by blast |
|
121 |
||
122 |
lemma wf_on_induct: |
|
123 |
"[| wf[A](r); a:A; |
|
124 |
!!x.[| x: A; ALL y:A. <y,x>: r --> P(y) |] ==> P(x) |
|
125 |
|] ==> P(a)" |
|
126 |
apply (unfold wf_on_def) |
|
127 |
apply (erule wf_induct2, assumption) |
|
128 |
apply (rule field_Int_square, blast) |
|
129 |
done |
|
130 |
||
13203
fac77a839aa2
Tidying up. Mainly moving proofs from Main.thy to other (Isar) theory files.
paulson
parents:
13175
diff
changeset
|
131 |
(*fixed up for induct method*) |
fac77a839aa2
Tidying up. Mainly moving proofs from Main.thy to other (Isar) theory files.
paulson
parents:
13175
diff
changeset
|
132 |
lemmas wf_on_induct = wf_on_induct [consumes 2, induct set: wf_on] |
fac77a839aa2
Tidying up. Mainly moving proofs from Main.thy to other (Isar) theory files.
paulson
parents:
13175
diff
changeset
|
133 |
and wf_on_induct_rule = |
fac77a839aa2
Tidying up. Mainly moving proofs from Main.thy to other (Isar) theory files.
paulson
parents:
13175
diff
changeset
|
134 |
wf_on_induct [rule_format, consumes 2, induct set: wf_on] |
fac77a839aa2
Tidying up. Mainly moving proofs from Main.thy to other (Isar) theory files.
paulson
parents:
13175
diff
changeset
|
135 |
|
fac77a839aa2
Tidying up. Mainly moving proofs from Main.thy to other (Isar) theory files.
paulson
parents:
13175
diff
changeset
|
136 |
|
13165 | 137 |
(*If r allows well-founded induction then wf(r)*) |
138 |
lemma wfI: |
|
139 |
"[| field(r)<=A; |
|
140 |
!!y B. [| ALL x:A. (ALL y:A. <y,x>:r --> y:B) --> x:B; y:A|] |
|
141 |
==> y:B |] |
|
142 |
==> wf(r)" |
|
143 |
apply (rule wf_on_subset_A [THEN wf_on_field_imp_wf]) |
|
144 |
apply (rule wf_onI2) |
|
145 |
prefer 2 apply blast |
|
146 |
apply blast |
|
147 |
done |
|
148 |
||
149 |
||
150 |
(*** Properties of well-founded relations ***) |
|
151 |
||
152 |
lemma wf_not_refl: "wf(r) ==> <a,a> ~: r" |
|
153 |
by (erule_tac a=a in wf_induct, blast) |
|
154 |
||
155 |
lemma wf_not_sym [rule_format]: "wf(r) ==> ALL x. <a,x>:r --> <x,a> ~: r" |
|
156 |
by (erule_tac a=a in wf_induct, blast) |
|
157 |
||
158 |
(* [| wf(r); <a,x> : r; ~P ==> <x,a> : r |] ==> P *) |
|
159 |
lemmas wf_asym = wf_not_sym [THEN swap, standard] |
|
160 |
||
161 |
lemma wf_on_not_refl: "[| wf[A](r); a: A |] ==> <a,a> ~: r" |
|
162 |
apply (erule_tac a=a in wf_on_induct, assumption) |
|
163 |
apply blast |
|
164 |
done |
|
0 | 165 |
|
13165 | 166 |
lemma wf_on_not_sym [rule_format]: |
167 |
"[| wf[A](r); a:A |] ==> ALL b:A. <a,b>:r --> <b,a>~:r" |
|
168 |
apply (erule_tac a=a in wf_on_induct, assumption) |
|
169 |
apply blast |
|
170 |
done |
|
171 |
||
172 |
lemma wf_on_asym: |
|
173 |
"[| wf[A](r); ~Z ==> <a,b> : r; |
|
174 |
<b,a> ~: r ==> Z; ~Z ==> a : A; ~Z ==> b : A |] ==> Z" |
|
175 |
by (blast dest: wf_on_not_sym); |
|
176 |
||
177 |
||
178 |
(*Needed to prove well_ordI. Could also reason that wf[A](r) means |
|
179 |
wf(r Int A*A); thus wf( (r Int A*A)^+ ) and use wf_not_refl *) |
|
180 |
lemma wf_on_chain3: |
|
181 |
"[| wf[A](r); <a,b>:r; <b,c>:r; <c,a>:r; a:A; b:A; c:A |] ==> P" |
|
182 |
apply (subgoal_tac "ALL y:A. ALL z:A. <a,y>:r --> <y,z>:r --> <z,a>:r --> P", |
|
183 |
blast) |
|
184 |
apply (erule_tac a=a in wf_on_induct, assumption) |
|
185 |
apply blast |
|
186 |
done |
|
187 |
||
188 |
||
189 |
||
190 |
||
191 |
(*transitive closure of a WF relation is WF provided A is downwards closed*) |
|
192 |
lemma wf_on_trancl: |
|
193 |
"[| wf[A](r); r-``A <= A |] ==> wf[A](r^+)" |
|
194 |
apply (rule wf_onI2) |
|
195 |
apply (frule bspec [THEN mp], assumption+) |
|
196 |
apply (erule_tac a = "y" in wf_on_induct, assumption) |
|
197 |
apply (blast elim: tranclE, blast) |
|
198 |
done |
|
199 |
||
200 |
lemma wf_trancl: "wf(r) ==> wf(r^+)" |
|
201 |
apply (simp add: wf_iff_wf_on_field) |
|
202 |
apply (rule wf_on_subset_A) |
|
203 |
apply (erule wf_on_trancl) |
|
204 |
apply blast |
|
205 |
apply (rule trancl_type [THEN field_rel_subset]) |
|
206 |
done |
|
207 |
||
208 |
||
209 |
||
210 |
(** r-``{a} is the set of everything under a in r **) |
|
211 |
||
212 |
lemmas underI = vimage_singleton_iff [THEN iffD2, standard] |
|
213 |
lemmas underD = vimage_singleton_iff [THEN iffD1, standard] |
|
214 |
||
215 |
(** is_recfun **) |
|
0 | 216 |
|
13165 | 217 |
lemma is_recfun_type: "is_recfun(r,a,H,f) ==> f: r-``{a} -> range(f)" |
218 |
apply (unfold is_recfun_def) |
|
219 |
apply (erule ssubst) |
|
220 |
apply (rule lamI [THEN rangeI, THEN lam_type], assumption) |
|
221 |
done |
|
222 |
||
223 |
lemma apply_recfun: |
|
224 |
"[| is_recfun(r,a,H,f); <x,a>:r |] ==> f`x = H(x, restrict(f,r-``{x}))" |
|
225 |
apply (unfold is_recfun_def) |
|
13175
81082cfa5618
new definition of "apply" and new simprule "beta_if"
paulson
parents:
13165
diff
changeset
|
226 |
txt{*replace f only on the left-hand side*} |
81082cfa5618
new definition of "apply" and new simprule "beta_if"
paulson
parents:
13165
diff
changeset
|
227 |
apply (erule_tac P = "%x.?t(x) = ?u" in ssubst) |
81082cfa5618
new definition of "apply" and new simprule "beta_if"
paulson
parents:
13165
diff
changeset
|
228 |
apply (simp add: underI); |
13165 | 229 |
done |
230 |
||
231 |
lemma is_recfun_equal [rule_format]: |
|
232 |
"[| wf(r); trans(r); is_recfun(r,a,H,f); is_recfun(r,b,H,g) |] |
|
233 |
==> <x,a>:r --> <x,b>:r --> f`x=g`x" |
|
234 |
apply (frule_tac f = "f" in is_recfun_type) |
|
235 |
apply (frule_tac f = "g" in is_recfun_type) |
|
236 |
apply (simp add: is_recfun_def) |
|
237 |
apply (erule_tac a=x in wf_induct) |
|
238 |
apply (intro impI) |
|
239 |
apply (elim ssubst) |
|
240 |
apply (simp (no_asm_simp) add: vimage_singleton_iff restrict_def) |
|
241 |
apply (rule_tac t = "%z. H (?x,z) " in subst_context) |
|
242 |
apply (subgoal_tac "ALL y : r-``{x}. ALL z. <y,z>:f <-> <y,z>:g") |
|
243 |
apply (blast dest: transD) |
|
244 |
apply (simp add: apply_iff) |
|
245 |
apply (blast dest: transD intro: sym) |
|
246 |
done |
|
247 |
||
248 |
lemma is_recfun_cut: |
|
249 |
"[| wf(r); trans(r); |
|
250 |
is_recfun(r,a,H,f); is_recfun(r,b,H,g); <b,a>:r |] |
|
251 |
==> restrict(f, r-``{b}) = g" |
|
252 |
apply (frule_tac f = "f" in is_recfun_type) |
|
253 |
apply (rule fun_extension) |
|
254 |
apply (blast dest: transD intro: restrict_type2) |
|
255 |
apply (erule is_recfun_type, simp) |
|
256 |
apply (blast dest: transD intro: is_recfun_equal) |
|
257 |
done |
|
258 |
||
259 |
(*** Main Existence Lemma ***) |
|
435 | 260 |
|
13165 | 261 |
lemma is_recfun_functional: |
262 |
"[| wf(r); trans(r); is_recfun(r,a,H,f); is_recfun(r,a,H,g) |] ==> f=g" |
|
263 |
by (blast intro: fun_extension is_recfun_type is_recfun_equal) |
|
264 |
||
265 |
(*If some f satisfies is_recfun(r,a,H,-) then so does the_recfun(r,a,H) *) |
|
266 |
lemma is_the_recfun: |
|
267 |
"[| is_recfun(r,a,H,f); wf(r); trans(r) |] |
|
268 |
==> is_recfun(r, a, H, the_recfun(r,a,H))" |
|
269 |
apply (unfold the_recfun_def) |
|
270 |
apply (rule ex1I [THEN theI], assumption) |
|
271 |
apply (blast intro: is_recfun_functional) |
|
272 |
done |
|
273 |
||
274 |
lemma unfold_the_recfun: |
|
275 |
"[| wf(r); trans(r) |] ==> is_recfun(r, a, H, the_recfun(r,a,H))" |
|
276 |
apply (rule_tac a=a in wf_induct, assumption) |
|
277 |
apply (rename_tac a1) |
|
278 |
apply (rule_tac f = "lam y: r-``{a1}. wftrec (r,y,H)" in is_the_recfun) |
|
279 |
apply typecheck |
|
280 |
apply (unfold is_recfun_def wftrec_def) |
|
281 |
(*Applying the substitution: must keep the quantified assumption!!*) |
|
282 |
apply (rule lam_cong [OF refl]) |
|
283 |
apply (drule underD) |
|
284 |
apply (fold is_recfun_def) |
|
285 |
apply (rule_tac t = "%z. H(?x,z)" in subst_context) |
|
286 |
apply (rule fun_extension) |
|
287 |
apply (blast intro: is_recfun_type) |
|
288 |
apply (rule lam_type [THEN restrict_type2]) |
|
289 |
apply blast |
|
290 |
apply (blast dest: transD) |
|
291 |
apply (frule spec [THEN mp], assumption) |
|
292 |
apply (subgoal_tac "<xa,a1> : r") |
|
293 |
apply (drule_tac x1 = "xa" in spec [THEN mp], assumption) |
|
13175
81082cfa5618
new definition of "apply" and new simprule "beta_if"
paulson
parents:
13165
diff
changeset
|
294 |
apply (simp add: vimage_singleton_iff |
13165 | 295 |
apply_recfun is_recfun_cut) |
296 |
apply (blast dest: transD) |
|
297 |
done |
|
298 |
||
299 |
||
300 |
(*** Unfolding wftrec ***) |
|
301 |
||
302 |
lemma the_recfun_cut: |
|
303 |
"[| wf(r); trans(r); <b,a>:r |] |
|
304 |
==> restrict(the_recfun(r,a,H), r-``{b}) = the_recfun(r,b,H)" |
|
305 |
by (blast intro: is_recfun_cut unfold_the_recfun); |
|
0 | 306 |
|
13165 | 307 |
(*NOT SUITABLE FOR REWRITING: it is recursive!*) |
308 |
lemma wftrec: |
|
309 |
"[| wf(r); trans(r) |] ==> |
|
310 |
wftrec(r,a,H) = H(a, lam x: r-``{a}. wftrec(r,x,H))" |
|
311 |
apply (unfold wftrec_def) |
|
312 |
apply (subst unfold_the_recfun [unfolded is_recfun_def]) |
|
313 |
apply (simp_all add: vimage_singleton_iff [THEN iff_sym] the_recfun_cut) |
|
314 |
done |
|
315 |
||
316 |
(** Removal of the premise trans(r) **) |
|
317 |
||
318 |
(*NOT SUITABLE FOR REWRITING: it is recursive!*) |
|
319 |
lemma wfrec: |
|
320 |
"wf(r) ==> wfrec(r,a,H) = H(a, lam x:r-``{a}. wfrec(r,x,H))" |
|
321 |
apply (unfold wfrec_def) |
|
322 |
apply (erule wf_trancl [THEN wftrec, THEN ssubst]) |
|
323 |
apply (rule trans_trancl) |
|
324 |
apply (rule vimage_pair_mono [THEN restrict_lam_eq, THEN subst_context]) |
|
325 |
apply (erule r_into_trancl) |
|
326 |
apply (rule subset_refl) |
|
327 |
done |
|
0 | 328 |
|
13165 | 329 |
(*This form avoids giant explosions in proofs. NOTE USE OF == *) |
330 |
lemma def_wfrec: |
|
331 |
"[| !!x. h(x)==wfrec(r,x,H); wf(r) |] ==> |
|
332 |
h(a) = H(a, lam x: r-``{a}. h(x))" |
|
333 |
apply simp |
|
334 |
apply (elim wfrec) |
|
335 |
done |
|
336 |
||
337 |
lemma wfrec_type: |
|
338 |
"[| wf(r); a:A; field(r)<=A; |
|
339 |
!!x u. [| x: A; u: Pi(r-``{x}, B) |] ==> H(x,u) : B(x) |
|
340 |
|] ==> wfrec(r,a,H) : B(a)" |
|
341 |
apply (rule_tac a = "a" in wf_induct2, assumption+) |
|
342 |
apply (subst wfrec, assumption) |
|
343 |
apply (simp add: lam_type underD) |
|
344 |
done |
|
345 |
||
346 |
||
347 |
lemma wfrec_on: |
|
348 |
"[| wf[A](r); a: A |] ==> |
|
349 |
wfrec[A](r,a,H) = H(a, lam x: (r-``{a}) Int A. wfrec[A](r,x,H))" |
|
350 |
apply (unfold wf_on_def wfrec_on_def) |
|
351 |
apply (erule wfrec [THEN trans]) |
|
352 |
apply (simp add: vimage_Int_square cons_subset_iff) |
|
353 |
done |
|
0 | 354 |
|
13165 | 355 |
(*Minimal-element characterization of well-foundedness*) |
356 |
lemma wf_eq_minimal: |
|
357 |
"wf(r) <-> (ALL Q x. x:Q --> (EX z:Q. ALL y. <y,z>:r --> y~:Q))" |
|
358 |
apply (unfold wf_def, blast) |
|
359 |
done |
|
360 |
||
361 |
ML |
|
362 |
{* |
|
363 |
val wf_def = thm "wf_def"; |
|
364 |
val wf_on_def = thm "wf_on_def"; |
|
0 | 365 |
|
13165 | 366 |
val wf_imp_wf_on = thm "wf_imp_wf_on"; |
367 |
val wf_on_field_imp_wf = thm "wf_on_field_imp_wf"; |
|
368 |
val wf_iff_wf_on_field = thm "wf_iff_wf_on_field"; |
|
369 |
val wf_on_subset_A = thm "wf_on_subset_A"; |
|
370 |
val wf_on_subset_r = thm "wf_on_subset_r"; |
|
371 |
val wf_onI = thm "wf_onI"; |
|
372 |
val wf_onI2 = thm "wf_onI2"; |
|
373 |
val wf_induct = thm "wf_induct"; |
|
374 |
val wf_induct2 = thm "wf_induct2"; |
|
375 |
val field_Int_square = thm "field_Int_square"; |
|
376 |
val wf_on_induct = thm "wf_on_induct"; |
|
377 |
val wfI = thm "wfI"; |
|
378 |
val wf_not_refl = thm "wf_not_refl"; |
|
379 |
val wf_not_sym = thm "wf_not_sym"; |
|
380 |
val wf_asym = thm "wf_asym"; |
|
381 |
val wf_on_not_refl = thm "wf_on_not_refl"; |
|
382 |
val wf_on_not_sym = thm "wf_on_not_sym"; |
|
383 |
val wf_on_asym = thm "wf_on_asym"; |
|
384 |
val wf_on_chain3 = thm "wf_on_chain3"; |
|
385 |
val wf_on_trancl = thm "wf_on_trancl"; |
|
386 |
val wf_trancl = thm "wf_trancl"; |
|
387 |
val underI = thm "underI"; |
|
388 |
val underD = thm "underD"; |
|
389 |
val is_recfun_type = thm "is_recfun_type"; |
|
390 |
val apply_recfun = thm "apply_recfun"; |
|
391 |
val is_recfun_equal = thm "is_recfun_equal"; |
|
392 |
val is_recfun_cut = thm "is_recfun_cut"; |
|
393 |
val is_recfun_functional = thm "is_recfun_functional"; |
|
394 |
val is_the_recfun = thm "is_the_recfun"; |
|
395 |
val unfold_the_recfun = thm "unfold_the_recfun"; |
|
396 |
val the_recfun_cut = thm "the_recfun_cut"; |
|
397 |
val wftrec = thm "wftrec"; |
|
398 |
val wfrec = thm "wfrec"; |
|
399 |
val def_wfrec = thm "def_wfrec"; |
|
400 |
val wfrec_type = thm "wfrec_type"; |
|
401 |
val wfrec_on = thm "wfrec_on"; |
|
402 |
val wf_eq_minimal = thm "wf_eq_minimal"; |
|
403 |
*} |
|
435 | 404 |
|
0 | 405 |
end |