src/ZF/Constructible/AC_in_L.thy
author ballarin
Thu Dec 11 18:30:26 2008 +0100 (2008-12-11)
changeset 29223 e09c53289830
parent 21404 eb85850d3eb7
child 32960 69916a850301
permissions -rw-r--r--
Conversion of HOL-Main and ZF to new locales.
paulson@13543
     1
(*  Title:      ZF/Constructible/AC_in_L.thy
paulson@13543
     2
    ID: $Id$
paulson@13543
     3
    Author:     Lawrence C Paulson, Cambridge University Computer Laboratory
paulson@13543
     4
*)
paulson@13543
     5
paulson@13543
     6
header {* The Axiom of Choice Holds in L! *}
paulson@13543
     7
haftmann@16417
     8
theory AC_in_L imports Formula begin
paulson@13543
     9
paulson@13543
    10
subsection{*Extending a Wellordering over a List -- Lexicographic Power*}
paulson@13543
    11
paulson@13543
    12
text{*This could be moved into a library.*}
paulson@13543
    13
paulson@13543
    14
consts
paulson@13543
    15
  rlist   :: "[i,i]=>i"
paulson@13543
    16
paulson@13543
    17
inductive
paulson@13543
    18
  domains "rlist(A,r)" \<subseteq> "list(A) * list(A)"
paulson@13543
    19
  intros
paulson@13543
    20
    shorterI:
paulson@13692
    21
      "[| length(l') < length(l); l' \<in> list(A); l \<in> list(A) |]
paulson@13543
    22
       ==> <l', l> \<in> rlist(A,r)"
paulson@13543
    23
paulson@13543
    24
    sameI:
paulson@13692
    25
      "[| <l',l> \<in> rlist(A,r); a \<in> A |]
paulson@13543
    26
       ==> <Cons(a,l'), Cons(a,l)> \<in> rlist(A,r)"
paulson@13543
    27
paulson@13543
    28
    diffI:
paulson@13692
    29
      "[| length(l') = length(l); <a',a> \<in> r;
paulson@13692
    30
          l' \<in> list(A); l \<in> list(A); a' \<in> A; a \<in> A |]
paulson@13543
    31
       ==> <Cons(a',l'), Cons(a,l)> \<in> rlist(A,r)"
paulson@13543
    32
  type_intros list.intros
paulson@13543
    33
paulson@13543
    34
paulson@13543
    35
subsubsection{*Type checking*}
paulson@13543
    36
paulson@13543
    37
lemmas rlist_type = rlist.dom_subset
paulson@13543
    38
paulson@13543
    39
lemmas field_rlist = rlist_type [THEN field_rel_subset]
paulson@13543
    40
paulson@13543
    41
subsubsection{*Linearity*}
paulson@13543
    42
paulson@13543
    43
lemma rlist_Nil_Cons [intro]:
paulson@13543
    44
    "[|a \<in> A; l \<in> list(A)|] ==> <[], Cons(a,l)> \<in> rlist(A, r)"
paulson@13692
    45
by (simp add: shorterI)
paulson@13543
    46
paulson@13543
    47
lemma linear_rlist:
paulson@13543
    48
    "linear(A,r) ==> linear(list(A),rlist(A,r))"
paulson@13543
    49
apply (simp (no_asm_simp) add: linear_def)
paulson@13692
    50
apply (rule ballI)
paulson@13692
    51
apply (induct_tac x)
paulson@13692
    52
 apply (rule ballI)
paulson@13692
    53
 apply (induct_tac y)
paulson@13692
    54
  apply (simp_all add: shorterI)
paulson@13692
    55
apply (rule ballI)
paulson@13692
    56
apply (erule_tac a=y in list.cases)
paulson@13692
    57
 apply (rename_tac [2] a2 l2)
paulson@13543
    58
 apply (rule_tac [2] i = "length(l)" and j = "length(l2)" in Ord_linear_lt)
paulson@13692
    59
     apply (simp_all add: shorterI)
paulson@13692
    60
apply (erule_tac x=a and y=a2 in linearE)
paulson@13692
    61
    apply (simp_all add: diffI)
paulson@13692
    62
apply (blast intro: sameI)
paulson@13543
    63
done
paulson@13543
    64
paulson@13543
    65
paulson@13543
    66
subsubsection{*Well-foundedness*}
paulson@13543
    67
paulson@13543
    68
text{*Nothing preceeds Nil in this ordering.*}
paulson@13543
    69
inductive_cases rlist_NilE: " <l,[]> \<in> rlist(A,r)"
paulson@13543
    70
paulson@13543
    71
inductive_cases rlist_ConsE: " <l', Cons(x,l)> \<in> rlist(A,r)"
paulson@13543
    72
paulson@13543
    73
lemma not_rlist_Nil [simp]: " <l,[]> \<notin> rlist(A,r)"
paulson@13543
    74
by (blast intro: elim: rlist_NilE)
paulson@13543
    75
paulson@13543
    76
lemma rlist_imp_length_le: "<l',l> \<in> rlist(A,r) ==> length(l') \<le> length(l)"
paulson@13543
    77
apply (erule rlist.induct)
paulson@13692
    78
apply (simp_all add: leI)
paulson@13543
    79
done
paulson@13543
    80
paulson@13543
    81
lemma wf_on_rlist_n:
paulson@13543
    82
  "[| n \<in> nat; wf[A](r) |] ==> wf[{l \<in> list(A). length(l) = n}](rlist(A,r))"
paulson@13692
    83
apply (induct_tac n)
paulson@13692
    84
 apply (rule wf_onI2, simp)
paulson@13692
    85
apply (rule wf_onI2, clarify)
paulson@13692
    86
apply (erule_tac a=y in list.cases, clarify)
paulson@13543
    87
 apply (simp (no_asm_use))
paulson@13692
    88
apply clarify
paulson@13543
    89
apply (simp (no_asm_use))
paulson@13543
    90
apply (subgoal_tac "\<forall>l2 \<in> list(A). length(l2) = x --> Cons(a,l2) \<in> B", blast)
paulson@13543
    91
apply (erule_tac a=a in wf_on_induct, assumption)
paulson@13543
    92
apply (rule ballI)
paulson@13692
    93
apply (rule impI)
paulson@13543
    94
apply (erule_tac a=l2 in wf_on_induct, blast, clarify)
paulson@13692
    95
apply (rename_tac a' l2 l')
paulson@13692
    96
apply (drule_tac x="Cons(a',l')" in bspec, typecheck)
paulson@13692
    97
apply simp
paulson@13692
    98
apply (erule mp, clarify)
paulson@13543
    99
apply (erule rlist_ConsE, auto)
paulson@13543
   100
done
paulson@13543
   101
paulson@13543
   102
lemma list_eq_UN_length: "list(A) = (\<Union>n\<in>nat. {l \<in> list(A). length(l) = n})"
paulson@13543
   103
by (blast intro: length_type)
paulson@13543
   104
paulson@13543
   105
paulson@13543
   106
lemma wf_on_rlist: "wf[A](r) ==> wf[list(A)](rlist(A,r))"
paulson@13692
   107
apply (subst list_eq_UN_length)
paulson@13692
   108
apply (rule wf_on_Union)
paulson@13543
   109
  apply (rule wf_imp_wf_on [OF wf_Memrel [of nat]])
paulson@13543
   110
 apply (simp add: wf_on_rlist_n)
paulson@13692
   111
apply (frule rlist_type [THEN subsetD])
paulson@13692
   112
apply (simp add: length_type)
paulson@13543
   113
apply (drule rlist_imp_length_le)
paulson@13692
   114
apply (erule leE)
paulson@13692
   115
apply (simp_all add: lt_def)
paulson@13543
   116
done
paulson@13543
   117
paulson@13543
   118
paulson@13543
   119
lemma wf_rlist: "wf(r) ==> wf(rlist(field(r),r))"
paulson@13543
   120
apply (simp add: wf_iff_wf_on_field)
paulson@13543
   121
apply (rule wf_on_subset_A [OF _ field_rlist])
paulson@13692
   122
apply (blast intro: wf_on_rlist)
paulson@13543
   123
done
paulson@13543
   124
paulson@13543
   125
lemma well_ord_rlist:
paulson@13543
   126
     "well_ord(A,r) ==> well_ord(list(A), rlist(A,r))"
paulson@13543
   127
apply (rule well_ordI)
paulson@13543
   128
apply (simp add: well_ord_def wf_on_rlist)
paulson@13543
   129
apply (simp add: well_ord_def tot_ord_def linear_rlist)
paulson@13543
   130
done
paulson@13543
   131
paulson@13543
   132
paulson@13543
   133
subsection{*An Injection from Formulas into the Natural Numbers*}
paulson@13543
   134
paulson@13543
   135
text{*There is a well-known bijection between @{term "nat*nat"} and @{term
paulson@13543
   136
nat} given by the expression f(m,n) = triangle(m+n) + m, where triangle(k)
paulson@13543
   137
enumerates the triangular numbers and can be defined by triangle(0)=0,
paulson@13543
   138
triangle(succ(k)) = succ(k + triangle(k)).  Some small amount of effort is
paulson@13692
   139
needed to show that f is a bijection.  We already know that such a bijection exists by the theorem @{text well_ord_InfCard_square_eq}:
paulson@13692
   140
@{thm[display] well_ord_InfCard_square_eq[no_vars]}
paulson@13543
   141
paulson@13692
   142
However, this result merely states that there is a bijection between the two
paulson@13692
   143
sets.  It provides no means of naming a specific bijection.  Therefore, we
paulson@13692
   144
conduct the proofs under the assumption that a bijection exists.  The simplest
paulson@13692
   145
way to organize this is to use a locale.*}
paulson@13692
   146
paulson@13692
   147
text{*Locale for any arbitrary injection between @{term "nat*nat"}
paulson@13543
   148
      and @{term nat}*}
paulson@13543
   149
locale Nat_Times_Nat =
paulson@13543
   150
  fixes fn
paulson@13543
   151
  assumes fn_inj: "fn \<in> inj(nat*nat, nat)"
paulson@13543
   152
paulson@13543
   153
paulson@13543
   154
consts   enum :: "[i,i]=>i"
paulson@13543
   155
primrec
paulson@13543
   156
  "enum(f, Member(x,y)) = f ` <0, f ` <x,y>>"
paulson@13543
   157
  "enum(f, Equal(x,y)) = f ` <1, f ` <x,y>>"
paulson@13543
   158
  "enum(f, Nand(p,q)) = f ` <2, f ` <enum(f,p), enum(f,q)>>"
paulson@13543
   159
  "enum(f, Forall(p)) = f ` <succ(2), enum(f,p)>"
paulson@13543
   160
paulson@13543
   161
lemma (in Nat_Times_Nat) fn_type [TC,simp]:
paulson@13543
   162
    "[|x \<in> nat; y \<in> nat|] ==> fn`<x,y> \<in> nat"
paulson@13692
   163
by (blast intro: inj_is_fun [OF fn_inj] apply_funtype)
paulson@13543
   164
paulson@13543
   165
lemma (in Nat_Times_Nat) fn_iff:
paulson@13692
   166
    "[|x \<in> nat; y \<in> nat; u \<in> nat; v \<in> nat|]
paulson@13543
   167
     ==> (fn`<x,y> = fn`<u,v>) <-> (x=u & y=v)"
paulson@13692
   168
by (blast dest: inj_apply_equality [OF fn_inj])
paulson@13543
   169
paulson@13543
   170
lemma (in Nat_Times_Nat) enum_type [TC,simp]:
paulson@13543
   171
    "p \<in> formula ==> enum(fn,p) \<in> nat"
paulson@13692
   172
by (induct_tac p, simp_all)
paulson@13543
   173
paulson@13543
   174
lemma (in Nat_Times_Nat) enum_inject [rule_format]:
paulson@13543
   175
    "p \<in> formula ==> \<forall>q\<in>formula. enum(fn,p) = enum(fn,q) --> p=q"
paulson@13692
   176
apply (induct_tac p, simp_all)
paulson@13692
   177
   apply (rule ballI)
paulson@13692
   178
   apply (erule formula.cases)
paulson@13692
   179
   apply (simp_all add: fn_iff)
paulson@13692
   180
  apply (rule ballI)
paulson@13692
   181
  apply (erule formula.cases)
paulson@13692
   182
  apply (simp_all add: fn_iff)
paulson@13692
   183
 apply (rule ballI)
paulson@13692
   184
 apply (erule_tac a=qa in formula.cases)
paulson@13692
   185
 apply (simp_all add: fn_iff)
paulson@13692
   186
 apply blast
paulson@13692
   187
apply (rule ballI)
paulson@13692
   188
apply (erule_tac a=q in formula.cases)
paulson@13692
   189
apply (simp_all add: fn_iff, blast)
paulson@13543
   190
done
paulson@13543
   191
paulson@13543
   192
lemma (in Nat_Times_Nat) inj_formula_nat:
paulson@13543
   193
    "(\<lambda>p \<in> formula. enum(fn,p)) \<in> inj(formula, nat)"
paulson@13692
   194
apply (simp add: inj_def lam_type)
paulson@13692
   195
apply (blast intro: enum_inject)
paulson@13543
   196
done
paulson@13543
   197
paulson@13543
   198
lemma (in Nat_Times_Nat) well_ord_formula:
paulson@13543
   199
    "well_ord(formula, measure(formula, enum(fn)))"
paulson@13543
   200
apply (rule well_ord_measure, simp)
paulson@13692
   201
apply (blast intro: enum_inject)
paulson@13543
   202
done
paulson@13543
   203
paulson@13543
   204
lemmas nat_times_nat_lepoll_nat =
paulson@13543
   205
    InfCard_nat [THEN InfCard_square_eqpoll, THEN eqpoll_imp_lepoll]
paulson@13543
   206
paulson@13543
   207
paulson@13543
   208
text{*Not needed--but interesting?*}
paulson@13543
   209
theorem formula_lepoll_nat: "formula \<lesssim> nat"
paulson@13543
   210
apply (insert nat_times_nat_lepoll_nat)
paulson@13543
   211
apply (unfold lepoll_def)
paulson@13692
   212
apply (blast intro: Nat_Times_Nat.inj_formula_nat Nat_Times_Nat.intro)
paulson@13692
   213
done
paulson@13692
   214
paulson@13692
   215
paulson@13692
   216
subsection{*Defining the Wellordering on @{term "DPow(A)"}*}
paulson@13692
   217
paulson@13692
   218
text{*The objective is to build a wellordering on @{term "DPow(A)"} from a
paulson@13692
   219
given one on @{term A}.  We first introduce wellorderings for environments,
paulson@13692
   220
which are lists built over @{term "A"}.  We combine it with the enumeration of
paulson@13692
   221
formulas.  The order type of the resulting wellordering gives us a map from
paulson@13692
   222
(environment, formula) pairs into the ordinals.  For each member of @{term
paulson@13702
   223
"DPow(A)"}, we take the minimum such ordinal.*}
paulson@13692
   224
wenzelm@21233
   225
definition
wenzelm@21404
   226
  env_form_r :: "[i,i,i]=>i" where
paulson@13692
   227
    --{*wellordering on (environment, formula) pairs*}
paulson@13692
   228
   "env_form_r(f,r,A) ==
paulson@13692
   229
      rmult(list(A), rlist(A, r),
paulson@13692
   230
	    formula, measure(formula, enum(f)))"
paulson@13692
   231
wenzelm@21404
   232
definition
wenzelm@21404
   233
  env_form_map :: "[i,i,i,i]=>i" where
paulson@13692
   234
    --{*map from (environment, formula) pairs to ordinals*}
paulson@13692
   235
   "env_form_map(f,r,A,z)
paulson@13692
   236
      == ordermap(list(A) * formula, env_form_r(f,r,A)) ` z"
paulson@13692
   237
wenzelm@21404
   238
definition
wenzelm@21404
   239
  DPow_ord :: "[i,i,i,i,i]=>o" where
paulson@13692
   240
    --{*predicate that holds if @{term k} is a valid index for @{term X}*}
paulson@13702
   241
   "DPow_ord(f,r,A,X,k) ==
paulson@13692
   242
           \<exists>env \<in> list(A). \<exists>p \<in> formula.
paulson@13692
   243
             arity(p) \<le> succ(length(env)) &
paulson@13692
   244
             X = {x\<in>A. sats(A, p, Cons(x,env))} &
paulson@13692
   245
             env_form_map(f,r,A,<env,p>) = k"
paulson@13692
   246
wenzelm@21404
   247
definition
wenzelm@21404
   248
  DPow_least :: "[i,i,i,i]=>i" where
paulson@13692
   249
    --{*function yielding the smallest index for @{term X}*}
skalberg@14171
   250
   "DPow_least(f,r,A,X) == \<mu> k. DPow_ord(f,r,A,X,k)"
paulson@13692
   251
wenzelm@21404
   252
definition
wenzelm@21404
   253
  DPow_r :: "[i,i,i]=>i" where
paulson@13692
   254
    --{*a wellordering on @{term "DPow(A)"}*}
paulson@13702
   255
   "DPow_r(f,r,A) == measure(DPow(A), DPow_least(f,r,A))"
paulson@13692
   256
paulson@13692
   257
paulson@13692
   258
lemma (in Nat_Times_Nat) well_ord_env_form_r:
paulson@13692
   259
    "well_ord(A,r)
paulson@13692
   260
     ==> well_ord(list(A) * formula, env_form_r(fn,r,A))"
paulson@13692
   261
by (simp add: env_form_r_def well_ord_rmult well_ord_rlist well_ord_formula)
paulson@13692
   262
paulson@13692
   263
lemma (in Nat_Times_Nat) Ord_env_form_map:
paulson@13692
   264
    "[|well_ord(A,r); z \<in> list(A) * formula|]
paulson@13692
   265
     ==> Ord(env_form_map(fn,r,A,z))"
paulson@13692
   266
by (simp add: env_form_map_def Ord_ordermap well_ord_env_form_r)
paulson@13692
   267
paulson@13702
   268
lemma DPow_imp_ex_DPow_ord:
paulson@13702
   269
    "X \<in> DPow(A) ==> \<exists>k. DPow_ord(fn,r,A,X,k)"
paulson@13702
   270
apply (simp add: DPow_ord_def)
paulson@13692
   271
apply (blast dest!: DPowD)
paulson@13692
   272
done
paulson@13692
   273
paulson@13702
   274
lemma (in Nat_Times_Nat) DPow_ord_imp_Ord:
paulson@13702
   275
     "[|DPow_ord(fn,r,A,X,k); well_ord(A,r)|] ==> Ord(k)"
paulson@13702
   276
apply (simp add: DPow_ord_def, clarify)
paulson@13692
   277
apply (simp add: Ord_env_form_map)
paulson@13543
   278
done
paulson@13543
   279
paulson@13702
   280
lemma (in Nat_Times_Nat) DPow_imp_DPow_least:
paulson@13692
   281
    "[|X \<in> DPow(A); well_ord(A,r)|]
paulson@13702
   282
     ==> DPow_ord(fn, r, A, X, DPow_least(fn,r,A,X))"
paulson@13702
   283
apply (simp add: DPow_least_def)
paulson@13702
   284
apply (blast dest: DPow_imp_ex_DPow_ord intro: DPow_ord_imp_Ord LeastI)
paulson@13692
   285
done
paulson@13692
   286
paulson@13692
   287
lemma (in Nat_Times_Nat) env_form_map_inject:
paulson@13692
   288
    "[|env_form_map(fn,r,A,u) = env_form_map(fn,r,A,v); well_ord(A,r);
paulson@13692
   289
       u \<in> list(A) * formula;  v \<in> list(A) * formula|]
paulson@13692
   290
     ==> u=v"
paulson@13692
   291
apply (simp add: env_form_map_def)
paulson@13692
   292
apply (rule inj_apply_equality [OF bij_is_inj, OF ordermap_bij,
paulson@13692
   293
                                OF well_ord_env_form_r], assumption+)
paulson@13692
   294
done
paulson@13692
   295
paulson@13702
   296
lemma (in Nat_Times_Nat) DPow_ord_unique:
paulson@13702
   297
    "[|DPow_ord(fn,r,A,X,k); DPow_ord(fn,r,A,Y,k); well_ord(A,r)|]
paulson@13692
   298
     ==> X=Y"
paulson@13702
   299
apply (simp add: DPow_ord_def, clarify)
paulson@13692
   300
apply (drule env_form_map_inject, auto)
paulson@13692
   301
done
paulson@13692
   302
paulson@13702
   303
lemma (in Nat_Times_Nat) well_ord_DPow_r:
paulson@13702
   304
    "well_ord(A,r) ==> well_ord(DPow(A), DPow_r(fn,r,A))"
paulson@13702
   305
apply (simp add: DPow_r_def)
paulson@13692
   306
apply (rule well_ord_measure)
paulson@13702
   307
 apply (simp add: DPow_least_def Ord_Least)
paulson@13702
   308
apply (drule DPow_imp_DPow_least, assumption)+
paulson@13692
   309
apply simp
paulson@13702
   310
apply (blast intro: DPow_ord_unique)
paulson@13692
   311
done
paulson@13692
   312
paulson@13692
   313
lemma (in Nat_Times_Nat) DPow_r_type:
paulson@13702
   314
    "DPow_r(fn,r,A) \<subseteq> DPow(A) * DPow(A)"
paulson@13702
   315
by (simp add: DPow_r_def measure_def, blast)
paulson@13692
   316
paulson@13543
   317
paulson@13543
   318
subsection{*Limit Construction for Well-Orderings*}
paulson@13543
   319
paulson@13543
   320
text{*Now we work towards the transfinite definition of wellorderings for
paulson@13543
   321
@{term "Lset(i)"}.  We assume as an inductive hypothesis that there is a family
paulson@13543
   322
of wellorderings for smaller ordinals.*}
paulson@13543
   323
wenzelm@21233
   324
definition
wenzelm@21404
   325
  rlimit :: "[i,i=>i]=>i" where
paulson@13702
   326
  --{*Expresses the wellordering at limit ordinals.  The conditional
paulson@13702
   327
      lets us remove the premise @{term "Limit(i)"} from some theorems.*}
paulson@13692
   328
    "rlimit(i,r) ==
paulson@13702
   329
       if Limit(i) then 
paulson@13702
   330
	 {z: Lset(i) * Lset(i).
paulson@13702
   331
	  \<exists>x' x. z = <x',x> &
paulson@13702
   332
		 (lrank(x') < lrank(x) |
paulson@13702
   333
		  (lrank(x') = lrank(x) & <x',x> \<in> r(succ(lrank(x)))))}
paulson@13702
   334
       else 0"
paulson@13692
   335
wenzelm@21404
   336
definition
wenzelm@21404
   337
  Lset_new :: "i=>i" where
paulson@13692
   338
  --{*This constant denotes the set of elements introduced at level
paulson@13692
   339
      @{term "succ(i)"}*}
paulson@13543
   340
    "Lset_new(i) == {x \<in> Lset(succ(i)). lrank(x) = i}"
paulson@13543
   341
paulson@13543
   342
lemma Limit_Lset_eq2:
paulson@13543
   343
    "Limit(i) ==> Lset(i) = (\<Union>j\<in>i. Lset_new(j))"
paulson@13692
   344
apply (simp add: Limit_Lset_eq)
paulson@13543
   345
apply (rule equalityI)
paulson@13543
   346
 apply safe
paulson@13543
   347
 apply (subgoal_tac "Ord(y)")
paulson@13543
   348
  prefer 2 apply (blast intro: Ord_in_Ord Limit_is_Ord)
paulson@13692
   349
 apply (simp_all add: Limit_is_Ord Lset_iff_lrank_lt Lset_new_def
paulson@13692
   350
                      Ord_mem_iff_lt)
paulson@13692
   351
 apply (blast intro: lt_trans)
paulson@13543
   352
apply (rule_tac x = "succ(lrank(x))" in bexI)
paulson@13692
   353
 apply (simp add: Lset_succ_lrank_iff)
paulson@13692
   354
apply (blast intro: Limit_has_succ ltD)
paulson@13543
   355
done
paulson@13543
   356
paulson@13543
   357
lemma wf_on_Lset:
paulson@13543
   358
    "wf[Lset(succ(j))](r(succ(j))) ==> wf[Lset_new(j)](rlimit(i,r))"
paulson@13692
   359
apply (simp add: wf_on_def Lset_new_def)
paulson@13692
   360
apply (erule wf_subset)
paulson@13702
   361
apply (simp add: rlimit_def, force)
paulson@13543
   362
done
paulson@13543
   363
paulson@13543
   364
lemma wf_on_rlimit:
paulson@13702
   365
    "(\<forall>j<i. wf[Lset(j)](r(j))) ==> wf[Lset(i)](rlimit(i,r))"
paulson@13702
   366
apply (case_tac "Limit(i)") 
paulson@13702
   367
 prefer 2
paulson@13702
   368
 apply (simp add: rlimit_def wf_on_any_0)
paulson@13543
   369
apply (simp add: Limit_Lset_eq2)
paulson@13543
   370
apply (rule wf_on_Union)
paulson@13692
   371
  apply (rule wf_imp_wf_on [OF wf_Memrel [of i]])
paulson@13692
   372
 apply (blast intro: wf_on_Lset Limit_has_succ Limit_is_Ord ltI)
paulson@13543
   373
apply (force simp add: rlimit_def Limit_is_Ord Lset_iff_lrank_lt Lset_new_def
paulson@13543
   374
                       Ord_mem_iff_lt)
paulson@13543
   375
done
paulson@13543
   376
paulson@13543
   377
lemma linear_rlimit:
paulson@13543
   378
    "[|Limit(i); \<forall>j<i. linear(Lset(j), r(j)) |]
paulson@13543
   379
     ==> linear(Lset(i), rlimit(i,r))"
paulson@13692
   380
apply (frule Limit_is_Ord)
paulson@13692
   381
apply (simp add: Limit_Lset_eq2 Lset_new_def)
paulson@13692
   382
apply (simp add: linear_def rlimit_def Ball_def lt_Ord Lset_iff_lrank_lt)
paulson@13692
   383
apply (simp add: ltI, clarify)
paulson@13692
   384
apply (rename_tac u v)
paulson@13692
   385
apply (rule_tac i="lrank(u)" and j="lrank(v)" in Ord_linear_lt, simp_all) 
paulson@13692
   386
apply (drule_tac x="succ(lrank(u) Un lrank(v))" in ospec)
paulson@13692
   387
 apply (simp add: ltI)
paulson@13692
   388
apply (drule_tac x=u in spec, simp)
paulson@13692
   389
apply (drule_tac x=v in spec, simp)
paulson@13543
   390
done
paulson@13543
   391
paulson@13543
   392
lemma well_ord_rlimit:
paulson@13543
   393
    "[|Limit(i); \<forall>j<i. well_ord(Lset(j), r(j)) |]
paulson@13543
   394
     ==> well_ord(Lset(i), rlimit(i,r))"
paulson@13692
   395
by (blast intro: well_ordI wf_on_rlimit well_ord_is_wf
paulson@13692
   396
                           linear_rlimit well_ord_is_linear)
paulson@13543
   397
paulson@13702
   398
lemma rlimit_cong:
paulson@13702
   399
     "(!!j. j<i ==> r'(j) = r(j)) ==> rlimit(i,r) = rlimit(i,r')"
paulson@13702
   400
apply (simp add: rlimit_def, clarify) 
paulson@13702
   401
apply (rule refl iff_refl Collect_cong ex_cong conj_cong)+
paulson@13702
   402
apply (simp add: Limit_is_Ord Lset_lrank_lt)
paulson@13702
   403
done
paulson@13702
   404
paulson@13543
   405
paulson@13543
   406
subsection{*Transfinite Definition of the Wellordering on @{term "L"}*}
paulson@13543
   407
wenzelm@21233
   408
definition
wenzelm@21404
   409
  L_r :: "[i, i] => i" where
paulson@13702
   410
  "L_r(f) == %i.
paulson@13702
   411
      transrec3(i, 0, \<lambda>x r. DPow_r(f, r, Lset(x)), 
paulson@13702
   412
                \<lambda>x r. rlimit(x, \<lambda>y. r`y))"
paulson@13543
   413
paulson@13543
   414
subsubsection{*The Corresponding Recursion Equations*}
paulson@13543
   415
lemma [simp]: "L_r(f,0) = 0"
paulson@13702
   416
by (simp add: L_r_def)
paulson@13543
   417
paulson@13702
   418
lemma [simp]: "L_r(f, succ(i)) = DPow_r(f, L_r(f,i), Lset(i))"
paulson@13702
   419
by (simp add: L_r_def)
paulson@13543
   420
paulson@13702
   421
text{*The limit case is non-trivial because of the distinction between
paulson@13702
   422
object-level and meta-level abstraction.*}
paulson@13543
   423
lemma [simp]: "Limit(i) ==> L_r(f,i) = rlimit(i, L_r(f))"
paulson@13702
   424
by (simp cong: rlimit_cong add: transrec3_Limit L_r_def ltD)
paulson@13543
   425
paulson@13543
   426
lemma (in Nat_Times_Nat) L_r_type:
paulson@13543
   427
    "Ord(i) ==> L_r(fn,i) \<subseteq> Lset(i) * Lset(i)"
paulson@13543
   428
apply (induct i rule: trans_induct3_rule)
paulson@13692
   429
  apply (simp_all add: Lset_succ DPow_r_type well_ord_DPow_r rlimit_def
paulson@13692
   430
                       Transset_subset_DPow [OF Transset_Lset], blast)
paulson@13543
   431
done
paulson@13543
   432
paulson@13543
   433
lemma (in Nat_Times_Nat) well_ord_L_r:
paulson@13543
   434
    "Ord(i) ==> well_ord(Lset(i), L_r(fn,i))"
paulson@13543
   435
apply (induct i rule: trans_induct3_rule)
paulson@13692
   436
apply (simp_all add: well_ord0 Lset_succ L_r_type well_ord_DPow_r
paulson@13692
   437
                     well_ord_rlimit ltD)
paulson@13543
   438
done
paulson@13543
   439
paulson@13543
   440
lemma well_ord_L_r:
paulson@13543
   441
    "Ord(i) ==> \<exists>r. well_ord(Lset(i), r)"
paulson@13543
   442
apply (insert nat_times_nat_lepoll_nat)
paulson@13543
   443
apply (unfold lepoll_def)
paulson@13692
   444
apply (blast intro: Nat_Times_Nat.well_ord_L_r Nat_Times_Nat.intro)
paulson@13543
   445
done
paulson@13543
   446
paulson@13543
   447
paulson@13543
   448
text{*Locale for proving results under the assumption @{text "V=L"}*}
paulson@13543
   449
locale V_equals_L =
paulson@13543
   450
  assumes VL: "L(x)"
paulson@13543
   451
paulson@13543
   452
text{*The Axiom of Choice holds in @{term L}!  Or, to be precise, the
paulson@13543
   453
Wellordering Theorem.*}
paulson@13543
   454
theorem (in V_equals_L) AC: "\<exists>r. well_ord(x,r)"
paulson@13692
   455
apply (insert Transset_Lset VL [of x])
paulson@13543
   456
apply (simp add: Transset_def L_def)
paulson@13692
   457
apply (blast dest!: well_ord_L_r intro: well_ord_subset)
paulson@13543
   458
done
paulson@13543
   459
paulson@13543
   460
end