moved subset of 'HOL-Cardinals' needed for BNF into 'HOL'
authorblanchet
Mon, 20 Jan 2014 18:24:55 +0100
changeset 55054 e1f3714bc508
parent 55053 f69530f22f5a
child 55055 3f0dfce0e27a
moved subset of 'HOL-Cardinals' needed for BNF into 'HOL'
src/HOL/BNF/BNF_Util.thy
src/HOL/Cardinal_Arithmetic_FP.thy
src/HOL/Cardinal_Order_Relation_FP.thy
src/HOL/Cardinals/Cardinal_Arithmetic_FP.thy
src/HOL/Cardinals/Cardinal_Order_Relation_FP.thy
src/HOL/Cardinals/Constructions_on_Wellorders_FP.thy
src/HOL/Cardinals/Wellorder_Embedding_FP.thy
src/HOL/Cardinals/Wellorder_Relation_FP.thy
src/HOL/Constructions_on_Wellorders_FP.thy
src/HOL/Main.thy
src/HOL/ROOT
src/HOL/Wellorder_Embedding_FP.thy
src/HOL/Wellorder_Relation_FP.thy
--- a/src/HOL/BNF/BNF_Util.thy	Mon Jan 20 16:14:19 2014 +0100
+++ b/src/HOL/BNF/BNF_Util.thy	Mon Jan 20 18:24:55 2014 +0100
@@ -9,9 +9,8 @@
 header {* Library for Bounded Natural Functors *}
 
 theory BNF_Util
-imports "../Cardinals/Cardinal_Arithmetic_FP"
-   (*FIXME: define fun_rel here, reuse in Transfer once this theory is in HOL*)
-  Transfer
+imports Cardinal_Arithmetic_FP
+  Transfer (*FIXME: define fun_rel here, reuse in Transfer once this theory is in HOL*)
 begin
 
 definition collect where
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Cardinal_Arithmetic_FP.thy	Mon Jan 20 18:24:55 2014 +0100
@@ -0,0 +1,713 @@
+(*  Title:      HOL/Cardinal_Arithmetic_FP.thy
+    Author:     Dmitriy Traytel, TU Muenchen
+    Copyright   2012
+
+Cardinal arithmetic (FP).
+*)
+
+header {* Cardinal Arithmetic (FP) *}
+
+theory Cardinal_Arithmetic_FP
+imports Cardinal_Order_Relation_FP
+begin
+
+(*library candidate*)
+lemma dir_image: "\<lbrakk>\<And>x y. (f x = f y) = (x = y); Card_order r\<rbrakk> \<Longrightarrow> r =o dir_image r f"
+by (rule dir_image_ordIso) (auto simp add: inj_on_def card_order_on_def)
+
+(*should supersede a weaker lemma from the library*)
+lemma dir_image_Field: "Field (dir_image r f) = f ` Field r"
+unfolding dir_image_def Field_def Range_def Domain_def by fast
+
+lemma card_order_dir_image:
+  assumes bij: "bij f" and co: "card_order r"
+  shows "card_order (dir_image r f)"
+proof -
+  from assms have "Field (dir_image r f) = UNIV"
+    using card_order_on_Card_order[of UNIV r] unfolding bij_def dir_image_Field by auto
+  moreover from bij have "\<And>x y. (f x = f y) = (x = y)" unfolding bij_def inj_on_def by auto
+  with co have "Card_order (dir_image r f)"
+    using card_order_on_Card_order[of UNIV r] Card_order_ordIso2[OF _ dir_image] by blast
+  ultimately show ?thesis by auto
+qed
+
+(*library candidate*)
+lemma ordIso_refl: "Card_order r \<Longrightarrow> r =o r"
+by (rule card_order_on_ordIso)
+
+(*library candidate*)
+lemma ordLeq_refl: "Card_order r \<Longrightarrow> r \<le>o r"
+by (rule ordIso_imp_ordLeq, rule card_order_on_ordIso)
+
+(*library candidate*)
+lemma card_of_ordIso_subst: "A = B \<Longrightarrow> |A| =o |B|"
+by (simp only: ordIso_refl card_of_Card_order)
+
+(*library candidate*)
+lemma Field_card_order: "card_order r \<Longrightarrow> Field r = UNIV"
+using card_order_on_Card_order[of UNIV r] by simp
+
+(*library candidate*)
+lemma card_of_Times_Plus_distrib:
+  "|A <*> (B <+> C)| =o |A <*> B <+> A <*> C|" (is "|?RHS| =o |?LHS|")
+proof -
+  let ?f = "\<lambda>(a, bc). case bc of Inl b \<Rightarrow> Inl (a, b) | Inr c \<Rightarrow> Inr (a, c)"
+  have "bij_betw ?f ?RHS ?LHS" unfolding bij_betw_def inj_on_def by force
+  thus ?thesis using card_of_ordIso by blast
+qed
+
+(*library candidate*)
+lemma Func_Times_Range:
+  "|Func A (B <*> C)| =o |Func A B <*> Func A C|" (is "|?LHS| =o |?RHS|")
+proof -
+  let ?F = "\<lambda>fg. (\<lambda>x. if x \<in> A then fst (fg x) else undefined,
+                  \<lambda>x. if x \<in> A then snd (fg x) else undefined)"
+  let ?G = "\<lambda>(f, g) x. if x \<in> A then (f x, g x) else undefined"
+  have "bij_betw ?F ?LHS ?RHS" unfolding bij_betw_def inj_on_def
+  apply safe
+     apply (simp add: Func_def fun_eq_iff)
+     apply (metis (no_types) pair_collapse)
+    apply (auto simp: Func_def fun_eq_iff)[2]
+  proof -
+    fix f g assume "f \<in> Func A B" "g \<in> Func A C"
+    thus "(f, g) \<in> ?F ` Func A (B \<times> C)"
+      by (intro image_eqI[of _ _ "?G (f, g)"]) (auto simp: Func_def)
+  qed
+  thus ?thesis using card_of_ordIso by blast
+qed
+
+
+subsection {* Zero *}
+
+definition czero where
+  "czero = card_of {}"
+
+lemma czero_ordIso:
+  "czero =o czero"
+using card_of_empty_ordIso by (simp add: czero_def)
+
+lemma card_of_ordIso_czero_iff_empty:
+  "|A| =o (czero :: 'b rel) \<longleftrightarrow> A = ({} :: 'a set)"
+unfolding czero_def by (rule iffI[OF card_of_empty2]) (auto simp: card_of_refl card_of_empty_ordIso)
+
+(* A "not czero" Cardinal predicate *)
+abbreviation Cnotzero where
+  "Cnotzero (r :: 'a rel) \<equiv> \<not>(r =o (czero :: 'a rel)) \<and> Card_order r"
+
+(*helper*)
+lemma Cnotzero_imp_not_empty: "Cnotzero r \<Longrightarrow> Field r \<noteq> {}"
+by (metis Card_order_iff_ordIso_card_of czero_def)
+
+lemma czeroI:
+  "\<lbrakk>Card_order r; Field r = {}\<rbrakk> \<Longrightarrow> r =o czero"
+using Cnotzero_imp_not_empty ordIso_transitive[OF _ czero_ordIso] by blast
+
+lemma czeroE:
+  "r =o czero \<Longrightarrow> Field r = {}"
+unfolding czero_def
+by (drule card_of_cong) (simp only: Field_card_of card_of_empty2)
+
+lemma Cnotzero_mono:
+  "\<lbrakk>Cnotzero r; Card_order q; r \<le>o q\<rbrakk> \<Longrightarrow> Cnotzero q"
+apply (rule ccontr)
+apply auto
+apply (drule czeroE)
+apply (erule notE)
+apply (erule czeroI)
+apply (drule card_of_mono2)
+apply (simp only: card_of_empty3)
+done
+
+subsection {* (In)finite cardinals *}
+
+definition cinfinite where
+  "cinfinite r = (\<not> finite (Field r))"
+
+abbreviation Cinfinite where
+  "Cinfinite r \<equiv> cinfinite r \<and> Card_order r"
+
+definition cfinite where
+  "cfinite r = finite (Field r)"
+
+abbreviation Cfinite where
+  "Cfinite r \<equiv> cfinite r \<and> Card_order r"
+
+lemma Cfinite_ordLess_Cinfinite: "\<lbrakk>Cfinite r; Cinfinite s\<rbrakk> \<Longrightarrow> r <o s"
+  unfolding cfinite_def cinfinite_def
+  by (metis card_order_on_well_order_on finite_ordLess_infinite)
+
+lemmas natLeq_card_order = natLeq_Card_order[unfolded Field_natLeq]
+
+lemma natLeq_cinfinite: "cinfinite natLeq"
+unfolding cinfinite_def Field_natLeq by (metis infinite_UNIV_nat)
+
+lemma natLeq_ordLeq_cinfinite:
+  assumes inf: "Cinfinite r"
+  shows "natLeq \<le>o r"
+proof -
+  from inf have "natLeq \<le>o |Field r|" by (metis cinfinite_def infinite_iff_natLeq_ordLeq)
+  also from inf have "|Field r| =o r" by (simp add: card_of_unique ordIso_symmetric)
+  finally show ?thesis .
+qed
+
+lemma cinfinite_not_czero: "cinfinite r \<Longrightarrow> \<not> (r =o (czero :: 'a rel))"
+unfolding cinfinite_def by (metis czeroE finite.emptyI)
+
+lemma Cinfinite_Cnotzero: "Cinfinite r \<Longrightarrow> Cnotzero r"
+by (metis cinfinite_not_czero)
+
+lemma Cinfinite_cong: "\<lbrakk>r1 =o r2; Cinfinite r1\<rbrakk> \<Longrightarrow> Cinfinite r2"
+by (metis Card_order_ordIso2 card_of_mono2 card_of_ordLeq_infinite cinfinite_def ordIso_iff_ordLeq)
+
+lemma cinfinite_mono: "\<lbrakk>r1 \<le>o r2; cinfinite r1\<rbrakk> \<Longrightarrow> cinfinite r2"
+by (metis card_of_mono2 card_of_ordLeq_infinite cinfinite_def)
+
+
+subsection {* Binary sum *}
+
+definition csum (infixr "+c" 65) where
+  "r1 +c r2 \<equiv> |Field r1 <+> Field r2|"
+
+lemma Field_csum: "Field (r +c s) = Inl ` Field r \<union> Inr ` Field s"
+  unfolding csum_def Field_card_of by auto
+
+lemma Card_order_csum:
+  "Card_order (r1 +c r2)"
+unfolding csum_def by (simp add: card_of_Card_order)
+
+lemma csum_Cnotzero1:
+  "Cnotzero r1 \<Longrightarrow> Cnotzero (r1 +c r2)"
+unfolding csum_def
+by (metis Cnotzero_imp_not_empty Plus_eq_empty_conv card_of_Card_order card_of_ordIso_czero_iff_empty)
+
+lemma card_order_csum:
+  assumes "card_order r1" "card_order r2"
+  shows "card_order (r1 +c r2)"
+proof -
+  have "Field r1 = UNIV" "Field r2 = UNIV" using assms card_order_on_Card_order by auto
+  thus ?thesis unfolding csum_def by (auto simp: card_of_card_order_on)
+qed
+
+lemma cinfinite_csum:
+  "cinfinite r1 \<or> cinfinite r2 \<Longrightarrow> cinfinite (r1 +c r2)"
+unfolding cinfinite_def csum_def by (auto simp: Field_card_of)
+
+lemma Cinfinite_csum1:
+  "Cinfinite r1 \<Longrightarrow> Cinfinite (r1 +c r2)"
+unfolding cinfinite_def csum_def by (metis Field_card_of card_of_Card_order finite_Plus_iff)
+
+lemma Cinfinite_csum:
+  "Cinfinite r1 \<or> Cinfinite r2 \<Longrightarrow> Cinfinite (r1 +c r2)"
+unfolding cinfinite_def csum_def by (metis Field_card_of card_of_Card_order finite_Plus_iff)
+
+lemma Cinfinite_csum_strong:
+  "\<lbrakk>Cinfinite r1; Cinfinite r2\<rbrakk> \<Longrightarrow> Cinfinite (r1 +c r2)"
+by (metis Cinfinite_csum)
+
+lemma csum_cong: "\<lbrakk>p1 =o r1; p2 =o r2\<rbrakk> \<Longrightarrow> p1 +c p2 =o r1 +c r2"
+by (simp only: csum_def ordIso_Plus_cong)
+
+lemma csum_cong1: "p1 =o r1 \<Longrightarrow> p1 +c q =o r1 +c q"
+by (simp only: csum_def ordIso_Plus_cong1)
+
+lemma csum_cong2: "p2 =o r2 \<Longrightarrow> q +c p2 =o q +c r2"
+by (simp only: csum_def ordIso_Plus_cong2)
+
+lemma csum_mono: "\<lbrakk>p1 \<le>o r1; p2 \<le>o r2\<rbrakk> \<Longrightarrow> p1 +c p2 \<le>o r1 +c r2"
+by (simp only: csum_def ordLeq_Plus_mono)
+
+lemma csum_mono1: "p1 \<le>o r1 \<Longrightarrow> p1 +c q \<le>o r1 +c q"
+by (simp only: csum_def ordLeq_Plus_mono1)
+
+lemma csum_mono2: "p2 \<le>o r2 \<Longrightarrow> q +c p2 \<le>o q +c r2"
+by (simp only: csum_def ordLeq_Plus_mono2)
+
+lemma ordLeq_csum1: "Card_order p1 \<Longrightarrow> p1 \<le>o p1 +c p2"
+by (simp only: csum_def Card_order_Plus1)
+
+lemma ordLeq_csum2: "Card_order p2 \<Longrightarrow> p2 \<le>o p1 +c p2"
+by (simp only: csum_def Card_order_Plus2)
+
+lemma csum_com: "p1 +c p2 =o p2 +c p1"
+by (simp only: csum_def card_of_Plus_commute)
+
+lemma csum_assoc: "(p1 +c p2) +c p3 =o p1 +c p2 +c p3"
+by (simp only: csum_def Field_card_of card_of_Plus_assoc)
+
+lemma Cfinite_csum: "\<lbrakk>Cfinite r; Cfinite s\<rbrakk> \<Longrightarrow> Cfinite (r +c s)"
+  unfolding cfinite_def csum_def Field_card_of using card_of_card_order_on by simp
+
+lemma csum_csum: "(r1 +c r2) +c (r3 +c r4) =o (r1 +c r3) +c (r2 +c r4)"
+proof -
+  have "(r1 +c r2) +c (r3 +c r4) =o r1 +c r2 +c (r3 +c r4)"
+    by (metis csum_assoc)
+  also have "r1 +c r2 +c (r3 +c r4) =o r1 +c (r2 +c r3) +c r4"
+    by (metis csum_assoc csum_cong2 ordIso_symmetric)
+  also have "r1 +c (r2 +c r3) +c r4 =o r1 +c (r3 +c r2) +c r4"
+    by (metis csum_com csum_cong1 csum_cong2)
+  also have "r1 +c (r3 +c r2) +c r4 =o r1 +c r3 +c r2 +c r4"
+    by (metis csum_assoc csum_cong2 ordIso_symmetric)
+  also have "r1 +c r3 +c r2 +c r4 =o (r1 +c r3) +c (r2 +c r4)"
+    by (metis csum_assoc ordIso_symmetric)
+  finally show ?thesis .
+qed
+
+lemma Plus_csum: "|A <+> B| =o |A| +c |B|"
+by (simp only: csum_def Field_card_of card_of_refl)
+
+lemma Un_csum: "|A \<union> B| \<le>o |A| +c |B|"
+using ordLeq_ordIso_trans[OF card_of_Un_Plus_ordLeq Plus_csum] by blast
+
+
+subsection {* One *}
+
+definition cone where
+  "cone = card_of {()}"
+
+lemma Card_order_cone: "Card_order cone"
+unfolding cone_def by (rule card_of_Card_order)
+
+lemma Cfinite_cone: "Cfinite cone"
+  unfolding cfinite_def by (simp add: Card_order_cone)
+
+lemma cone_not_czero: "\<not> (cone =o czero)"
+unfolding czero_def cone_def by (metis empty_not_insert card_of_empty3[of "{()}"] ordIso_iff_ordLeq)
+
+lemma cone_ordLeq_Cnotzero: "Cnotzero r \<Longrightarrow> cone \<le>o r"
+unfolding cone_def by (metis Card_order_singl_ordLeq czeroI)
+
+
+subsection{* Two *}
+
+definition ctwo where
+  "ctwo = |UNIV :: bool set|"
+
+lemma Card_order_ctwo: "Card_order ctwo"
+unfolding ctwo_def by (rule card_of_Card_order)
+
+lemma ctwo_not_czero: "\<not> (ctwo =o czero)"
+using card_of_empty3[of "UNIV :: bool set"] ordIso_iff_ordLeq
+unfolding czero_def ctwo_def by (metis UNIV_not_empty)
+
+lemma ctwo_Cnotzero: "Cnotzero ctwo"
+by (simp add: ctwo_not_czero Card_order_ctwo)
+
+
+subsection {* Family sum *}
+
+definition Csum where
+  "Csum r rs \<equiv> |SIGMA i : Field r. Field (rs i)|"
+
+(* Similar setup to the one for SIGMA from theory Big_Operators: *)
+syntax "_Csum" ::
+  "pttrn => ('a * 'a) set => 'b * 'b set => (('a * 'b) * ('a * 'b)) set"
+  ("(3CSUM _:_. _)" [0, 51, 10] 10)
+
+translations
+  "CSUM i:r. rs" == "CONST Csum r (%i. rs)"
+
+lemma SIGMA_CSUM: "|SIGMA i : I. As i| = (CSUM i : |I|. |As i| )"
+by (auto simp: Csum_def Field_card_of)
+
+(* NB: Always, under the cardinal operator,
+operations on sets are reduced automatically to operations on cardinals.
+This should make cardinal reasoning more direct and natural.  *)
+
+
+subsection {* Product *}
+
+definition cprod (infixr "*c" 80) where
+  "r1 *c r2 = |Field r1 <*> Field r2|"
+
+lemma card_order_cprod:
+  assumes "card_order r1" "card_order r2"
+  shows "card_order (r1 *c r2)"
+proof -
+  have "Field r1 = UNIV" "Field r2 = UNIV" using assms card_order_on_Card_order by auto
+  thus ?thesis by (auto simp: cprod_def card_of_card_order_on)
+qed
+
+lemma Card_order_cprod: "Card_order (r1 *c r2)"
+by (simp only: cprod_def Field_card_of card_of_card_order_on)
+
+lemma cprod_mono1: "p1 \<le>o r1 \<Longrightarrow> p1 *c q \<le>o r1 *c q"
+by (simp only: cprod_def ordLeq_Times_mono1)
+
+lemma cprod_mono2: "p2 \<le>o r2 \<Longrightarrow> q *c p2 \<le>o q *c r2"
+by (simp only: cprod_def ordLeq_Times_mono2)
+
+lemma ordLeq_cprod2: "\<lbrakk>Cnotzero p1; Card_order p2\<rbrakk> \<Longrightarrow> p2 \<le>o p1 *c p2"
+unfolding cprod_def by (metis Card_order_Times2 czeroI)
+
+lemma cinfinite_cprod: "\<lbrakk>cinfinite r1; cinfinite r2\<rbrakk> \<Longrightarrow> cinfinite (r1 *c r2)"
+by (simp add: cinfinite_def cprod_def Field_card_of infinite_cartesian_product)
+
+lemma cinfinite_cprod2: "\<lbrakk>Cnotzero r1; Cinfinite r2\<rbrakk> \<Longrightarrow> cinfinite (r1 *c r2)"
+by (metis cinfinite_mono ordLeq_cprod2)
+
+lemma Cinfinite_cprod2: "\<lbrakk>Cnotzero r1; Cinfinite r2\<rbrakk> \<Longrightarrow> Cinfinite (r1 *c r2)"
+by (blast intro: cinfinite_cprod2 Card_order_cprod)
+
+lemma cprod_com: "p1 *c p2 =o p2 *c p1"
+by (simp only: cprod_def card_of_Times_commute)
+
+lemma card_of_Csum_Times:
+  "\<forall>i \<in> I. |A i| \<le>o |B| \<Longrightarrow> (CSUM i : |I|. |A i| ) \<le>o |I| *c |B|"
+by (simp only: Csum_def cprod_def Field_card_of card_of_Sigma_Times)
+
+lemma card_of_Csum_Times':
+  assumes "Card_order r" "\<forall>i \<in> I. |A i| \<le>o r"
+  shows "(CSUM i : |I|. |A i| ) \<le>o |I| *c r"
+proof -
+  from assms(1) have *: "r =o |Field r|" by (simp add: card_of_unique)
+  with assms(2) have "\<forall>i \<in> I. |A i| \<le>o |Field r|" by (blast intro: ordLeq_ordIso_trans)
+  hence "(CSUM i : |I|. |A i| ) \<le>o |I| *c |Field r|" by (simp only: card_of_Csum_Times)
+  also from * have "|I| *c |Field r| \<le>o |I| *c r"
+    by (simp only: Field_card_of card_of_refl cprod_def ordIso_imp_ordLeq)
+  finally show ?thesis .
+qed
+
+lemma cprod_csum_distrib1: "r1 *c r2 +c r1 *c r3 =o r1 *c (r2 +c r3)"
+unfolding csum_def cprod_def by (simp add: Field_card_of card_of_Times_Plus_distrib ordIso_symmetric)
+
+lemma csum_absorb2': "\<lbrakk>Card_order r2; r1 \<le>o r2; cinfinite r1 \<or> cinfinite r2\<rbrakk> \<Longrightarrow> r1 +c r2 =o r2"
+unfolding csum_def by (metis Card_order_Plus_infinite cinfinite_def cinfinite_mono)
+
+lemma csum_absorb1':
+  assumes card: "Card_order r2"
+  and r12: "r1 \<le>o r2" and cr12: "cinfinite r1 \<or> cinfinite r2"
+  shows "r2 +c r1 =o r2"
+by (rule ordIso_transitive, rule csum_com, rule csum_absorb2', (simp only: assms)+)
+
+lemma csum_absorb1: "\<lbrakk>Cinfinite r2; r1 \<le>o r2\<rbrakk> \<Longrightarrow> r2 +c r1 =o r2"
+by (rule csum_absorb1') auto
+
+
+subsection {* Exponentiation *}
+
+definition cexp (infixr "^c" 90) where
+  "r1 ^c r2 \<equiv> |Func (Field r2) (Field r1)|"
+
+lemma Card_order_cexp: "Card_order (r1 ^c r2)"
+unfolding cexp_def by (rule card_of_Card_order)
+
+lemma cexp_mono':
+  assumes 1: "p1 \<le>o r1" and 2: "p2 \<le>o r2"
+  and n: "Field p2 = {} \<Longrightarrow> Field r2 = {}"
+  shows "p1 ^c p2 \<le>o r1 ^c r2"
+proof(cases "Field p1 = {}")
+  case True
+  hence "|Field |Func (Field p2) (Field p1)|| \<le>o cone"
+    unfolding cone_def Field_card_of
+    by (cases "Field p2 = {}", auto intro: card_of_ordLeqI2 simp: Func_empty)
+       (metis Func_is_emp card_of_empty ex_in_conv)
+  hence "|Func (Field p2) (Field p1)| \<le>o cone" by (simp add: Field_card_of cexp_def)
+  hence "p1 ^c p2 \<le>o cone" unfolding cexp_def .
+  thus ?thesis
+  proof (cases "Field p2 = {}")
+    case True
+    with n have "Field r2 = {}" .
+    hence "cone \<le>o r1 ^c r2" unfolding cone_def cexp_def Func_def by (auto intro: card_of_ordLeqI)
+    thus ?thesis using `p1 ^c p2 \<le>o cone` ordLeq_transitive by auto
+  next
+    case False with True have "|Field (p1 ^c p2)| =o czero"
+      unfolding card_of_ordIso_czero_iff_empty cexp_def Field_card_of Func_def by auto
+    thus ?thesis unfolding cexp_def card_of_ordIso_czero_iff_empty Field_card_of
+      by (simp add: card_of_empty)
+  qed
+next
+  case False
+  have 1: "|Field p1| \<le>o |Field r1|" and 2: "|Field p2| \<le>o |Field r2|"
+    using 1 2 by (auto simp: card_of_mono2)
+  obtain f1 where f1: "f1 ` Field r1 = Field p1"
+    using 1 unfolding card_of_ordLeq2[OF False, symmetric] by auto
+  obtain f2 where f2: "inj_on f2 (Field p2)" "f2 ` Field p2 \<subseteq> Field r2"
+    using 2 unfolding card_of_ordLeq[symmetric] by blast
+  have 0: "Func_map (Field p2) f1 f2 ` (Field (r1 ^c r2)) = Field (p1 ^c p2)"
+    unfolding cexp_def Field_card_of using Func_map_surj[OF f1 f2 n, symmetric] .
+  have 00: "Field (p1 ^c p2) \<noteq> {}" unfolding cexp_def Field_card_of Func_is_emp
+    using False by simp
+  show ?thesis
+    using 0 card_of_ordLeq2[OF 00] unfolding cexp_def Field_card_of by blast
+qed
+
+lemma cexp_mono:
+  assumes 1: "p1 \<le>o r1" and 2: "p2 \<le>o r2"
+  and n: "p2 =o czero \<Longrightarrow> r2 =o czero" and card: "Card_order p2"
+  shows "p1 ^c p2 \<le>o r1 ^c r2"
+  by (metis (full_types) "1" "2" card cexp_mono' czeroE czeroI n)
+
+lemma cexp_mono1:
+  assumes 1: "p1 \<le>o r1" and q: "Card_order q"
+  shows "p1 ^c q \<le>o r1 ^c q"
+using ordLeq_refl[OF q] by (rule cexp_mono[OF 1]) (auto simp: q)
+
+lemma cexp_mono2':
+  assumes 2: "p2 \<le>o r2" and q: "Card_order q"
+  and n: "Field p2 = {} \<Longrightarrow> Field r2 = {}"
+  shows "q ^c p2 \<le>o q ^c r2"
+using ordLeq_refl[OF q] by (rule cexp_mono'[OF _ 2 n]) auto
+
+lemma cexp_mono2:
+  assumes 2: "p2 \<le>o r2" and q: "Card_order q"
+  and n: "p2 =o czero \<Longrightarrow> r2 =o czero" and card: "Card_order p2"
+  shows "q ^c p2 \<le>o q ^c r2"
+using ordLeq_refl[OF q] by (rule cexp_mono[OF _ 2 n card]) auto
+
+lemma cexp_mono2_Cnotzero:
+  assumes "p2 \<le>o r2" "Card_order q" "Cnotzero p2"
+  shows "q ^c p2 \<le>o q ^c r2"
+by (metis assms cexp_mono2' czeroI)
+
+lemma cexp_cong:
+  assumes 1: "p1 =o r1" and 2: "p2 =o r2"
+  and Cr: "Card_order r2"
+  and Cp: "Card_order p2"
+  shows "p1 ^c p2 =o r1 ^c r2"
+proof -
+  obtain f where "bij_betw f (Field p2) (Field r2)"
+    using 2 card_of_ordIso[of "Field p2" "Field r2"] card_of_cong by auto
+  hence 0: "Field p2 = {} \<longleftrightarrow> Field r2 = {}" unfolding bij_betw_def by auto
+  have r: "p2 =o czero \<Longrightarrow> r2 =o czero"
+    and p: "r2 =o czero \<Longrightarrow> p2 =o czero"
+     using 0 Cr Cp czeroE czeroI by auto
+  show ?thesis using 0 1 2 unfolding ordIso_iff_ordLeq
+    using r p cexp_mono[OF _ _ _ Cp] cexp_mono[OF _ _ _ Cr] by metis
+qed
+
+lemma cexp_cong1:
+  assumes 1: "p1 =o r1" and q: "Card_order q"
+  shows "p1 ^c q =o r1 ^c q"
+by (rule cexp_cong[OF 1 _ q q]) (rule ordIso_refl[OF q])
+
+lemma cexp_cong2:
+  assumes 2: "p2 =o r2" and q: "Card_order q" and p: "Card_order p2"
+  shows "q ^c p2 =o q ^c r2"
+by (rule cexp_cong[OF _ 2]) (auto simp only: ordIso_refl Card_order_ordIso2[OF p 2] q p)
+
+lemma cexp_cone:
+  assumes "Card_order r"
+  shows "r ^c cone =o r"
+proof -
+  have "r ^c cone =o |Field r|"
+    unfolding cexp_def cone_def Field_card_of Func_empty
+      card_of_ordIso[symmetric] bij_betw_def Func_def inj_on_def image_def
+    by (rule exI[of _ "\<lambda>f. f ()"]) auto
+  also have "|Field r| =o r" by (rule card_of_Field_ordIso[OF assms])
+  finally show ?thesis .
+qed
+
+lemma cexp_cprod:
+  assumes r1: "Card_order r1"
+  shows "(r1 ^c r2) ^c r3 =o r1 ^c (r2 *c r3)" (is "?L =o ?R")
+proof -
+  have "?L =o r1 ^c (r3 *c r2)"
+    unfolding cprod_def cexp_def Field_card_of
+    using card_of_Func_Times by(rule ordIso_symmetric)
+  also have "r1 ^c (r3 *c r2) =o ?R"
+    apply(rule cexp_cong2) using cprod_com r1 by (auto simp: Card_order_cprod)
+  finally show ?thesis .
+qed
+
+lemma cprod_infinite1': "\<lbrakk>Cinfinite r; Cnotzero p; p \<le>o r\<rbrakk> \<Longrightarrow> r *c p =o r"
+unfolding cinfinite_def cprod_def
+by (rule Card_order_Times_infinite[THEN conjunct1]) (blast intro: czeroI)+
+
+lemma cexp_cprod_ordLeq:
+  assumes r1: "Card_order r1" and r2: "Cinfinite r2"
+  and r3: "Cnotzero r3" "r3 \<le>o r2"
+  shows "(r1 ^c r2) ^c r3 =o r1 ^c r2" (is "?L =o ?R")
+proof-
+  have "?L =o r1 ^c (r2 *c r3)" using cexp_cprod[OF r1] .
+  also have "r1 ^c (r2 *c r3) =o ?R"
+  apply(rule cexp_cong2)
+  apply(rule cprod_infinite1'[OF r2 r3]) using r1 r2 by (fastforce simp: Card_order_cprod)+
+  finally show ?thesis .
+qed
+
+lemma Cnotzero_UNIV: "Cnotzero |UNIV|"
+by (auto simp: card_of_Card_order card_of_ordIso_czero_iff_empty)
+
+lemma ordLess_ctwo_cexp:
+  assumes "Card_order r"
+  shows "r <o ctwo ^c r"
+proof -
+  have "r <o |Pow (Field r)|" using assms by (rule Card_order_Pow)
+  also have "|Pow (Field r)| =o ctwo ^c r"
+    unfolding ctwo_def cexp_def Field_card_of by (rule card_of_Pow_Func)
+  finally show ?thesis .
+qed
+
+lemma ordLeq_cexp1:
+  assumes "Cnotzero r" "Card_order q"
+  shows "q \<le>o q ^c r"
+proof (cases "q =o (czero :: 'a rel)")
+  case True thus ?thesis by (simp only: card_of_empty cexp_def czero_def ordIso_ordLeq_trans)
+next
+  case False
+  thus ?thesis
+    apply -
+    apply (rule ordIso_ordLeq_trans)
+    apply (rule ordIso_symmetric)
+    apply (rule cexp_cone)
+    apply (rule assms(2))
+    apply (rule cexp_mono2)
+    apply (rule cone_ordLeq_Cnotzero)
+    apply (rule assms(1))
+    apply (rule assms(2))
+    apply (rule notE)
+    apply (rule cone_not_czero)
+    apply assumption
+    apply (rule Card_order_cone)
+  done
+qed
+
+lemma ordLeq_cexp2:
+  assumes "ctwo \<le>o q" "Card_order r"
+  shows "r \<le>o q ^c r"
+proof (cases "r =o (czero :: 'a rel)")
+  case True thus ?thesis by (simp only: card_of_empty cexp_def czero_def ordIso_ordLeq_trans)
+next
+  case False thus ?thesis
+    apply -
+    apply (rule ordLess_imp_ordLeq)
+    apply (rule ordLess_ordLeq_trans)
+    apply (rule ordLess_ctwo_cexp)
+    apply (rule assms(2))
+    apply (rule cexp_mono1)
+    apply (rule assms(1))
+    apply (rule assms(2))
+  done
+qed
+
+lemma cinfinite_cexp: "\<lbrakk>ctwo \<le>o q; Cinfinite r\<rbrakk> \<Longrightarrow> cinfinite (q ^c r)"
+by (metis assms cinfinite_mono ordLeq_cexp2)
+
+lemma Cinfinite_cexp:
+  "\<lbrakk>ctwo \<le>o q; Cinfinite r\<rbrakk> \<Longrightarrow> Cinfinite (q ^c r)"
+by (simp add: cinfinite_cexp Card_order_cexp)
+
+lemma ctwo_ordLess_natLeq: "ctwo <o natLeq"
+unfolding ctwo_def using finite_UNIV natLeq_cinfinite natLeq_Card_order
+by (intro Cfinite_ordLess_Cinfinite) (auto simp: cfinite_def card_of_Card_order)
+
+lemma ctwo_ordLess_Cinfinite: "Cinfinite r \<Longrightarrow> ctwo <o r"
+by (metis ctwo_ordLess_natLeq natLeq_ordLeq_cinfinite ordLess_ordLeq_trans)
+
+lemma ctwo_ordLeq_Cinfinite:
+  assumes "Cinfinite r"
+  shows "ctwo \<le>o r"
+by (rule ordLess_imp_ordLeq[OF ctwo_ordLess_Cinfinite[OF assms]])
+
+lemma Un_Cinfinite_bound: "\<lbrakk>|A| \<le>o r; |B| \<le>o r; Cinfinite r\<rbrakk> \<Longrightarrow> |A \<union> B| \<le>o r"
+by (auto simp add: cinfinite_def card_of_Un_ordLeq_infinite_Field)
+
+lemma UNION_Cinfinite_bound: "\<lbrakk>|I| \<le>o r; \<forall>i \<in> I. |A i| \<le>o r; Cinfinite r\<rbrakk> \<Longrightarrow> |\<Union>i \<in> I. A i| \<le>o r"
+by (auto simp add: card_of_UNION_ordLeq_infinite_Field cinfinite_def)
+
+lemma csum_cinfinite_bound:
+  assumes "p \<le>o r" "q \<le>o r" "Card_order p" "Card_order q" "Cinfinite r"
+  shows "p +c q \<le>o r"
+proof -
+  from assms(1-4) have "|Field p| \<le>o r" "|Field q| \<le>o r"
+    unfolding card_order_on_def using card_of_least ordLeq_transitive by blast+
+  with assms show ?thesis unfolding cinfinite_def csum_def
+    by (blast intro: card_of_Plus_ordLeq_infinite_Field)
+qed
+
+lemma cprod_cinfinite_bound:
+  assumes "p \<le>o r" "q \<le>o r" "Card_order p" "Card_order q" "Cinfinite r"
+  shows "p *c q \<le>o r"
+proof -
+  from assms(1-4) have "|Field p| \<le>o r" "|Field q| \<le>o r"
+    unfolding card_order_on_def using card_of_least ordLeq_transitive by blast+
+  with assms show ?thesis unfolding cinfinite_def cprod_def
+    by (blast intro: card_of_Times_ordLeq_infinite_Field)
+qed
+
+lemma cprod_csum_cexp:
+  "r1 *c r2 \<le>o (r1 +c r2) ^c ctwo"
+unfolding cprod_def csum_def cexp_def ctwo_def Field_card_of
+proof -
+  let ?f = "\<lambda>(a, b). %x. if x then Inl a else Inr b"
+  have "inj_on ?f (Field r1 \<times> Field r2)" (is "inj_on _ ?LHS")
+    by (auto simp: inj_on_def fun_eq_iff split: bool.split)
+  moreover
+  have "?f ` ?LHS \<subseteq> Func (UNIV :: bool set) (Field r1 <+> Field r2)" (is "_ \<subseteq> ?RHS")
+    by (auto simp: Func_def)
+  ultimately show "|?LHS| \<le>o |?RHS|" using card_of_ordLeq by blast
+qed
+
+lemma Cfinite_cprod_Cinfinite: "\<lbrakk>Cfinite r; Cinfinite s\<rbrakk> \<Longrightarrow> r *c s \<le>o s"
+by (intro cprod_cinfinite_bound)
+  (auto intro: ordLeq_refl ordLess_imp_ordLeq[OF Cfinite_ordLess_Cinfinite])
+
+lemma cprod_cexp: "(r *c s) ^c t =o r ^c t *c s ^c t"
+  unfolding cprod_def cexp_def Field_card_of by (rule Func_Times_Range)
+
+lemma cprod_cexp_csum_cexp_Cinfinite:
+  assumes t: "Cinfinite t"
+  shows "(r *c s) ^c t \<le>o (r +c s) ^c t"
+proof -
+  have "(r *c s) ^c t \<le>o ((r +c s) ^c ctwo) ^c t"
+    by (rule cexp_mono1[OF cprod_csum_cexp conjunct2[OF t]])
+  also have "((r +c s) ^c ctwo) ^c t =o (r +c s) ^c (ctwo *c t)"
+    by (rule cexp_cprod[OF Card_order_csum])
+  also have "(r +c s) ^c (ctwo *c t) =o (r +c s) ^c (t *c ctwo)"
+    by (rule cexp_cong2[OF cprod_com Card_order_csum Card_order_cprod])
+  also have "(r +c s) ^c (t *c ctwo) =o ((r +c s) ^c t) ^c ctwo"
+    by (rule ordIso_symmetric[OF cexp_cprod[OF Card_order_csum]])
+  also have "((r +c s) ^c t) ^c ctwo =o (r +c s) ^c t"
+    by (rule cexp_cprod_ordLeq[OF Card_order_csum t ctwo_Cnotzero ctwo_ordLeq_Cinfinite[OF t]])
+  finally show ?thesis .
+qed
+
+lemma Cfinite_cexp_Cinfinite:
+  assumes s: "Cfinite s" and t: "Cinfinite t"
+  shows "s ^c t \<le>o ctwo ^c t"
+proof (cases "s \<le>o ctwo")
+  case True thus ?thesis using t by (blast intro: cexp_mono1)
+next
+  case False
+  hence "ctwo \<le>o s" by (metis card_order_on_well_order_on ctwo_Cnotzero ordLeq_total s)
+  hence "Cnotzero s" by (metis Cnotzero_mono ctwo_Cnotzero s)
+  hence st: "Cnotzero (s *c t)" by (metis Cinfinite_cprod2 cinfinite_not_czero t)
+  have "s ^c t \<le>o (ctwo ^c s) ^c t"
+    using assms by (blast intro: cexp_mono1 ordLess_imp_ordLeq[OF ordLess_ctwo_cexp])
+  also have "(ctwo ^c s) ^c t =o ctwo ^c (s *c t)"
+    by (blast intro: Card_order_ctwo cexp_cprod)
+  also have "ctwo ^c (s *c t) \<le>o ctwo ^c t"
+    using assms st by (intro cexp_mono2_Cnotzero Cfinite_cprod_Cinfinite Card_order_ctwo)
+  finally show ?thesis .
+qed
+
+lemma csum_Cfinite_cexp_Cinfinite:
+  assumes r: "Card_order r" and s: "Cfinite s" and t: "Cinfinite t"
+  shows "(r +c s) ^c t \<le>o (r +c ctwo) ^c t"
+proof (cases "Cinfinite r")
+  case True
+  hence "r +c s =o r" by (intro csum_absorb1 ordLess_imp_ordLeq[OF Cfinite_ordLess_Cinfinite] s)
+  hence "(r +c s) ^c t =o r ^c t" using t by (blast intro: cexp_cong1)
+  also have "r ^c t \<le>o (r +c ctwo) ^c t" using t by (blast intro: cexp_mono1 ordLeq_csum1 r)
+  finally show ?thesis .
+next
+  case False
+  with r have "Cfinite r" unfolding cinfinite_def cfinite_def by auto
+  hence "Cfinite (r +c s)" by (intro Cfinite_csum s)
+  hence "(r +c s) ^c t \<le>o ctwo ^c t" by (intro Cfinite_cexp_Cinfinite t)
+  also have "ctwo ^c t \<le>o (r +c ctwo) ^c t" using t
+    by (blast intro: cexp_mono1 ordLeq_csum2 Card_order_ctwo)
+  finally show ?thesis .
+qed
+
+(* cardSuc *)
+
+lemma Cinfinite_cardSuc: "Cinfinite r \<Longrightarrow> Cinfinite (cardSuc r)"
+by (simp add: cinfinite_def cardSuc_Card_order cardSuc_finite)
+
+lemma cardSuc_UNION_Cinfinite:
+  assumes "Cinfinite r" "relChain (cardSuc r) As" "B \<le> (UN i : Field (cardSuc r). As i)" "|B| <=o r"
+  shows "EX i : Field (cardSuc r). B \<le> As i"
+using cardSuc_UNION assms unfolding cinfinite_def by blast
+
+end
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Cardinal_Order_Relation_FP.thy	Mon Jan 20 18:24:55 2014 +0100
@@ -0,0 +1,1828 @@
+(*  Title:      HOL/Cardinal_Order_Relation_FP.thy
+    Author:     Andrei Popescu, TU Muenchen
+    Copyright   2012
+
+Cardinal-order relations (FP).
+*)
+
+header {* Cardinal-Order Relations (FP) *}
+
+theory Cardinal_Order_Relation_FP
+imports Constructions_on_Wellorders_FP
+begin
+
+
+text{* In this section, we define cardinal-order relations to be minim well-orders
+on their field.  Then we define the cardinal of a set to be {\em some} cardinal-order
+relation on that set, which will be unique up to order isomorphism.  Then we study
+the connection between cardinals and:
+\begin{itemize}
+\item standard set-theoretic constructions: products,
+sums, unions, lists, powersets, set-of finite sets operator;
+\item finiteness and infiniteness (in particular, with the numeric cardinal operator
+for finite sets, @{text "card"}, from the theory @{text "Finite_Sets.thy"}).
+\end{itemize}
+%
+On the way, we define the canonical $\omega$ cardinal and finite cardinals.  We also
+define (again, up to order isomorphism) the successor of a cardinal, and show that
+any cardinal admits a successor.
+
+Main results of this section are the existence of cardinal relations and the
+facts that, in the presence of infiniteness,
+most of the standard set-theoretic constructions (except for the powerset)
+{\em do not increase cardinality}.  In particular, e.g., the set of words/lists over
+any infinite set has the same cardinality (hence, is in bijection) with that set.
+*}
+
+
+subsection {* Cardinal orders *}
+
+
+text{* A cardinal order in our setting shall be a well-order {\em minim} w.r.t. the
+order-embedding relation, @{text "\<le>o"} (which is the same as being {\em minimal} w.r.t. the
+strict order-embedding relation, @{text "<o"}), among all the well-orders on its field.  *}
+
+definition card_order_on :: "'a set \<Rightarrow> 'a rel \<Rightarrow> bool"
+where
+"card_order_on A r \<equiv> well_order_on A r \<and> (\<forall>r'. well_order_on A r' \<longrightarrow> r \<le>o r')"
+
+
+abbreviation "Card_order r \<equiv> card_order_on (Field r) r"
+abbreviation "card_order r \<equiv> card_order_on UNIV r"
+
+
+lemma card_order_on_well_order_on:
+assumes "card_order_on A r"
+shows "well_order_on A r"
+using assms unfolding card_order_on_def by simp
+
+
+lemma card_order_on_Card_order:
+"card_order_on A r \<Longrightarrow> A = Field r \<and> Card_order r"
+unfolding card_order_on_def using well_order_on_Field by blast
+
+
+text{* The existence of a cardinal relation on any given set (which will mean
+that any set has a cardinal) follows from two facts:
+\begin{itemize}
+\item Zermelo's theorem (proved in @{text "Zorn.thy"} as theorem @{text "well_order_on"}),
+which states that on any given set there exists a well-order;
+\item The well-founded-ness of @{text "<o"}, ensuring that then there exists a minimal
+such well-order, i.e., a cardinal order.
+\end{itemize}
+*}
+
+
+theorem card_order_on: "\<exists>r. card_order_on A r"
+proof-
+  obtain R where R_def: "R = {r. well_order_on A r}" by blast
+  have 1: "R \<noteq> {} \<and> (\<forall>r \<in> R. Well_order r)"
+  using well_order_on[of A] R_def well_order_on_Well_order by blast
+  hence "\<exists>r \<in> R. \<forall>r' \<in> R. r \<le>o r'"
+  using  exists_minim_Well_order[of R] by auto
+  thus ?thesis using R_def unfolding card_order_on_def by auto
+qed
+
+
+lemma card_order_on_ordIso:
+assumes CO: "card_order_on A r" and CO': "card_order_on A r'"
+shows "r =o r'"
+using assms unfolding card_order_on_def
+using ordIso_iff_ordLeq by blast
+
+
+lemma Card_order_ordIso:
+assumes CO: "Card_order r" and ISO: "r' =o r"
+shows "Card_order r'"
+using ISO unfolding ordIso_def
+proof(unfold card_order_on_def, auto)
+  fix p' assume "well_order_on (Field r') p'"
+  hence 0: "Well_order p' \<and> Field p' = Field r'"
+  using well_order_on_Well_order by blast
+  obtain f where 1: "iso r' r f" and 2: "Well_order r \<and> Well_order r'"
+  using ISO unfolding ordIso_def by auto
+  hence 3: "inj_on f (Field r') \<and> f ` (Field r') = Field r"
+  by (auto simp add: iso_iff embed_inj_on)
+  let ?p = "dir_image p' f"
+  have 4: "p' =o ?p \<and> Well_order ?p"
+  using 0 2 3 by (auto simp add: dir_image_ordIso Well_order_dir_image)
+  moreover have "Field ?p =  Field r"
+  using 0 3 by (auto simp add: dir_image_Field2 order_on_defs)
+  ultimately have "well_order_on (Field r) ?p" by auto
+  hence "r \<le>o ?p" using CO unfolding card_order_on_def by auto
+  thus "r' \<le>o p'"
+  using ISO 4 ordLeq_ordIso_trans ordIso_ordLeq_trans ordIso_symmetric by blast
+qed
+
+
+lemma Card_order_ordIso2:
+assumes CO: "Card_order r" and ISO: "r =o r'"
+shows "Card_order r'"
+using assms Card_order_ordIso ordIso_symmetric by blast
+
+
+subsection {* Cardinal of a set *}
+
+
+text{* We define the cardinal of set to be {\em some} cardinal order on that set.
+We shall prove that this notion is unique up to order isomorphism, meaning
+that order isomorphism shall be the true identity of cardinals.  *}
+
+
+definition card_of :: "'a set \<Rightarrow> 'a rel" ("|_|" )
+where "card_of A = (SOME r. card_order_on A r)"
+
+
+lemma card_of_card_order_on: "card_order_on A |A|"
+unfolding card_of_def by (auto simp add: card_order_on someI_ex)
+
+
+lemma card_of_well_order_on: "well_order_on A |A|"
+using card_of_card_order_on card_order_on_def by blast
+
+
+lemma Field_card_of: "Field |A| = A"
+using card_of_card_order_on[of A] unfolding card_order_on_def
+using well_order_on_Field by blast
+
+
+lemma card_of_Card_order: "Card_order |A|"
+by (simp only: card_of_card_order_on Field_card_of)
+
+
+corollary ordIso_card_of_imp_Card_order:
+"r =o |A| \<Longrightarrow> Card_order r"
+using card_of_Card_order Card_order_ordIso by blast
+
+
+lemma card_of_Well_order: "Well_order |A|"
+using card_of_Card_order unfolding card_order_on_def by auto
+
+
+lemma card_of_refl: "|A| =o |A|"
+using card_of_Well_order ordIso_reflexive by blast
+
+
+lemma card_of_least: "well_order_on A r \<Longrightarrow> |A| \<le>o r"
+using card_of_card_order_on unfolding card_order_on_def by blast
+
+
+lemma card_of_ordIso:
+"(\<exists>f. bij_betw f A B) = ( |A| =o |B| )"
+proof(auto)
+  fix f assume *: "bij_betw f A B"
+  then obtain r where "well_order_on B r \<and> |A| =o r"
+  using Well_order_iso_copy card_of_well_order_on by blast
+  hence "|B| \<le>o |A|" using card_of_least
+  ordLeq_ordIso_trans ordIso_symmetric by blast
+  moreover
+  {let ?g = "inv_into A f"
+   have "bij_betw ?g B A" using * bij_betw_inv_into by blast
+   then obtain r where "well_order_on A r \<and> |B| =o r"
+   using Well_order_iso_copy card_of_well_order_on by blast
+   hence "|A| \<le>o |B|" using card_of_least
+   ordLeq_ordIso_trans ordIso_symmetric by blast
+  }
+  ultimately show "|A| =o |B|" using ordIso_iff_ordLeq by blast
+next
+  assume "|A| =o |B|"
+  then obtain f where "iso ( |A| ) ( |B| ) f"
+  unfolding ordIso_def by auto
+  hence "bij_betw f A B" unfolding iso_def Field_card_of by simp
+  thus "\<exists>f. bij_betw f A B" by auto
+qed
+
+
+lemma card_of_ordLeq:
+"(\<exists>f. inj_on f A \<and> f ` A \<le> B) = ( |A| \<le>o |B| )"
+proof(auto)
+  fix f assume *: "inj_on f A" and **: "f ` A \<le> B"
+  {assume "|B| <o |A|"
+   hence "|B| \<le>o |A|" using ordLeq_iff_ordLess_or_ordIso by blast
+   then obtain g where "embed ( |B| ) ( |A| ) g"
+   unfolding ordLeq_def by auto
+   hence 1: "inj_on g B \<and> g ` B \<le> A" using embed_inj_on[of "|B|" "|A|" "g"]
+   card_of_Well_order[of "B"] Field_card_of[of "B"] Field_card_of[of "A"]
+   embed_Field[of "|B|" "|A|" g] by auto
+   obtain h where "bij_betw h A B"
+   using * ** 1 Cantor_Bernstein[of f] by fastforce
+   hence "|A| =o |B|" using card_of_ordIso by blast
+   hence "|A| \<le>o |B|" using ordIso_iff_ordLeq by auto
+  }
+  thus "|A| \<le>o |B|" using ordLess_or_ordLeq[of "|B|" "|A|"]
+  by (auto simp: card_of_Well_order)
+next
+  assume *: "|A| \<le>o |B|"
+  obtain f where "embed ( |A| ) ( |B| ) f"
+  using * unfolding ordLeq_def by auto
+  hence "inj_on f A \<and> f ` A \<le> B" using embed_inj_on[of "|A|" "|B|" f]
+  card_of_Well_order[of "A"] Field_card_of[of "A"] Field_card_of[of "B"]
+  embed_Field[of "|A|" "|B|" f] by auto
+  thus "\<exists>f. inj_on f A \<and> f ` A \<le> B" by auto
+qed
+
+
+lemma card_of_ordLeq2:
+"A \<noteq> {} \<Longrightarrow> (\<exists>g. g ` B = A) = ( |A| \<le>o |B| )"
+using card_of_ordLeq[of A B] inj_on_iff_surj[of A B] by auto
+
+
+lemma card_of_ordLess:
+"(\<not>(\<exists>f. inj_on f A \<and> f ` A \<le> B)) = ( |B| <o |A| )"
+proof-
+  have "(\<not>(\<exists>f. inj_on f A \<and> f ` A \<le> B)) = (\<not> |A| \<le>o |B| )"
+  using card_of_ordLeq by blast
+  also have "\<dots> = ( |B| <o |A| )"
+  using card_of_Well_order[of A] card_of_Well_order[of B]
+        not_ordLeq_iff_ordLess by blast
+  finally show ?thesis .
+qed
+
+
+lemma card_of_ordLess2:
+"B \<noteq> {} \<Longrightarrow> (\<not>(\<exists>f. f ` A = B)) = ( |A| <o |B| )"
+using card_of_ordLess[of B A] inj_on_iff_surj[of B A] by auto
+
+
+lemma card_of_ordIsoI:
+assumes "bij_betw f A B"
+shows "|A| =o |B|"
+using assms unfolding card_of_ordIso[symmetric] by auto
+
+
+lemma card_of_ordLeqI:
+assumes "inj_on f A" and "\<And> a. a \<in> A \<Longrightarrow> f a \<in> B"
+shows "|A| \<le>o |B|"
+using assms unfolding card_of_ordLeq[symmetric] by auto
+
+
+lemma card_of_unique:
+"card_order_on A r \<Longrightarrow> r =o |A|"
+by (simp only: card_order_on_ordIso card_of_card_order_on)
+
+
+lemma card_of_mono1:
+"A \<le> B \<Longrightarrow> |A| \<le>o |B|"
+using inj_on_id[of A] card_of_ordLeq[of A B] by fastforce
+
+
+lemma card_of_mono2:
+assumes "r \<le>o r'"
+shows "|Field r| \<le>o |Field r'|"
+proof-
+  obtain f where
+  1: "well_order_on (Field r) r \<and> well_order_on (Field r) r \<and> embed r r' f"
+  using assms unfolding ordLeq_def
+  by (auto simp add: well_order_on_Well_order)
+  hence "inj_on f (Field r) \<and> f ` (Field r) \<le> Field r'"
+  by (auto simp add: embed_inj_on embed_Field)
+  thus "|Field r| \<le>o |Field r'|" using card_of_ordLeq by blast
+qed
+
+
+lemma card_of_cong: "r =o r' \<Longrightarrow> |Field r| =o |Field r'|"
+by (simp add: ordIso_iff_ordLeq card_of_mono2)
+
+
+lemma card_of_Field_ordLess: "Well_order r \<Longrightarrow> |Field r| \<le>o r"
+using card_of_least card_of_well_order_on well_order_on_Well_order by blast
+
+
+lemma card_of_Field_ordIso:
+assumes "Card_order r"
+shows "|Field r| =o r"
+proof-
+  have "card_order_on (Field r) r"
+  using assms card_order_on_Card_order by blast
+  moreover have "card_order_on (Field r) |Field r|"
+  using card_of_card_order_on by blast
+  ultimately show ?thesis using card_order_on_ordIso by blast
+qed
+
+
+lemma Card_order_iff_ordIso_card_of:
+"Card_order r = (r =o |Field r| )"
+using ordIso_card_of_imp_Card_order card_of_Field_ordIso ordIso_symmetric by blast
+
+
+lemma Card_order_iff_ordLeq_card_of:
+"Card_order r = (r \<le>o |Field r| )"
+proof-
+  have "Card_order r = (r =o |Field r| )"
+  unfolding Card_order_iff_ordIso_card_of by simp
+  also have "... = (r \<le>o |Field r| \<and> |Field r| \<le>o r)"
+  unfolding ordIso_iff_ordLeq by simp
+  also have "... = (r \<le>o |Field r| )"
+  using card_of_Field_ordLess
+  by (auto simp: card_of_Field_ordLess ordLeq_Well_order_simp)
+  finally show ?thesis .
+qed
+
+
+lemma Card_order_iff_Restr_underS:
+assumes "Well_order r"
+shows "Card_order r = (\<forall>a \<in> Field r. Restr r (underS r a) <o |Field r| )"
+using assms unfolding Card_order_iff_ordLeq_card_of
+using ordLeq_iff_ordLess_Restr card_of_Well_order by blast
+
+
+lemma card_of_underS:
+assumes r: "Card_order r" and a: "a : Field r"
+shows "|underS r a| <o r"
+proof-
+  let ?A = "underS r a"  let ?r' = "Restr r ?A"
+  have 1: "Well_order r"
+  using r unfolding card_order_on_def by simp
+  have "Well_order ?r'" using 1 Well_order_Restr by auto
+  moreover have "card_order_on (Field ?r') |Field ?r'|"
+  using card_of_card_order_on .
+  ultimately have "|Field ?r'| \<le>o ?r'"
+  unfolding card_order_on_def by simp
+  moreover have "Field ?r' = ?A"
+  using 1 wo_rel.underS_ofilter Field_Restr_ofilter
+  unfolding wo_rel_def by fastforce
+  ultimately have "|?A| \<le>o ?r'" by simp
+  also have "?r' <o |Field r|"
+  using 1 a r Card_order_iff_Restr_underS by blast
+  also have "|Field r| =o r"
+  using r ordIso_symmetric unfolding Card_order_iff_ordIso_card_of by auto
+  finally show ?thesis .
+qed
+
+
+lemma ordLess_Field:
+assumes "r <o r'"
+shows "|Field r| <o r'"
+proof-
+  have "well_order_on (Field r) r" using assms unfolding ordLess_def
+  by (auto simp add: well_order_on_Well_order)
+  hence "|Field r| \<le>o r" using card_of_least by blast
+  thus ?thesis using assms ordLeq_ordLess_trans by blast
+qed
+
+
+lemma internalize_card_of_ordLeq:
+"( |A| \<le>o r) = (\<exists>B \<le> Field r. |A| =o |B| \<and> |B| \<le>o r)"
+proof
+  assume "|A| \<le>o r"
+  then obtain p where 1: "Field p \<le> Field r \<and> |A| =o p \<and> p \<le>o r"
+  using internalize_ordLeq[of "|A|" r] by blast
+  hence "Card_order p" using card_of_Card_order Card_order_ordIso2 by blast
+  hence "|Field p| =o p" using card_of_Field_ordIso by blast
+  hence "|A| =o |Field p| \<and> |Field p| \<le>o r"
+  using 1 ordIso_equivalence ordIso_ordLeq_trans by blast
+  thus "\<exists>B \<le> Field r. |A| =o |B| \<and> |B| \<le>o r" using 1 by blast
+next
+  assume "\<exists>B \<le> Field r. |A| =o |B| \<and> |B| \<le>o r"
+  thus "|A| \<le>o r" using ordIso_ordLeq_trans by blast
+qed
+
+
+lemma internalize_card_of_ordLeq2:
+"( |A| \<le>o |C| ) = (\<exists>B \<le> C. |A| =o |B| \<and> |B| \<le>o |C| )"
+using internalize_card_of_ordLeq[of "A" "|C|"] Field_card_of[of C] by auto
+
+
+
+subsection {* Cardinals versus set operations on arbitrary sets *}
+
+
+text{* Here we embark in a long journey of simple results showing
+that the standard set-theoretic operations are well-behaved w.r.t. the notion of
+cardinal -- essentially, this means that they preserve the ``cardinal identity"
+@{text "=o"} and are monotonic w.r.t. @{text "\<le>o"}.
+*}
+
+
+lemma card_of_empty: "|{}| \<le>o |A|"
+using card_of_ordLeq inj_on_id by blast
+
+
+lemma card_of_empty1:
+assumes "Well_order r \<or> Card_order r"
+shows "|{}| \<le>o r"
+proof-
+  have "Well_order r" using assms unfolding card_order_on_def by auto
+  hence "|Field r| <=o r"
+  using assms card_of_Field_ordLess by blast
+  moreover have "|{}| \<le>o |Field r|" by (simp add: card_of_empty)
+  ultimately show ?thesis using ordLeq_transitive by blast
+qed
+
+
+corollary Card_order_empty:
+"Card_order r \<Longrightarrow> |{}| \<le>o r" by (simp add: card_of_empty1)
+
+
+lemma card_of_empty2:
+assumes LEQ: "|A| =o |{}|"
+shows "A = {}"
+using assms card_of_ordIso[of A] bij_betw_empty2 by blast
+
+
+lemma card_of_empty3:
+assumes LEQ: "|A| \<le>o |{}|"
+shows "A = {}"
+using assms
+by (simp add: ordIso_iff_ordLeq card_of_empty1 card_of_empty2
+              ordLeq_Well_order_simp)
+
+
+lemma card_of_empty_ordIso:
+"|{}::'a set| =o |{}::'b set|"
+using card_of_ordIso unfolding bij_betw_def inj_on_def by blast
+
+
+lemma card_of_image:
+"|f ` A| <=o |A|"
+proof(cases "A = {}", simp add: card_of_empty)
+  assume "A ~= {}"
+  hence "f ` A ~= {}" by auto
+  thus "|f ` A| \<le>o |A|"
+  using card_of_ordLeq2[of "f ` A" A] by auto
+qed
+
+
+lemma surj_imp_ordLeq:
+assumes "B <= f ` A"
+shows "|B| <=o |A|"
+proof-
+  have "|B| <=o |f ` A|" using assms card_of_mono1 by auto
+  thus ?thesis using card_of_image ordLeq_transitive by blast
+qed
+
+
+lemma card_of_ordLeqI2:
+assumes "B \<subseteq> f ` A"
+shows "|B| \<le>o |A|"
+using assms by (metis surj_imp_ordLeq)
+
+
+lemma card_of_singl_ordLeq:
+assumes "A \<noteq> {}"
+shows "|{b}| \<le>o |A|"
+proof-
+  obtain a where *: "a \<in> A" using assms by auto
+  let ?h = "\<lambda> b'::'b. if b' = b then a else undefined"
+  have "inj_on ?h {b} \<and> ?h ` {b} \<le> A"
+  using * unfolding inj_on_def by auto
+  thus ?thesis using card_of_ordLeq by fast
+qed
+
+
+corollary Card_order_singl_ordLeq:
+"\<lbrakk>Card_order r; Field r \<noteq> {}\<rbrakk> \<Longrightarrow> |{b}| \<le>o r"
+using card_of_singl_ordLeq[of "Field r" b]
+      card_of_Field_ordIso[of r] ordLeq_ordIso_trans by blast
+
+
+lemma card_of_Pow: "|A| <o |Pow A|"
+using card_of_ordLess2[of "Pow A" A]  Cantors_paradox[of A]
+      Pow_not_empty[of A] by auto
+
+
+corollary Card_order_Pow:
+"Card_order r \<Longrightarrow> r <o |Pow(Field r)|"
+using card_of_Pow card_of_Field_ordIso ordIso_ordLess_trans ordIso_symmetric by blast
+
+
+lemma card_of_Plus1: "|A| \<le>o |A <+> B|"
+proof-
+  have "Inl ` A \<le> A <+> B" by auto
+  thus ?thesis using inj_Inl[of A] card_of_ordLeq by blast
+qed
+
+
+corollary Card_order_Plus1:
+"Card_order r \<Longrightarrow> r \<le>o |(Field r) <+> B|"
+using card_of_Plus1 card_of_Field_ordIso ordIso_ordLeq_trans ordIso_symmetric by blast
+
+
+lemma card_of_Plus2: "|B| \<le>o |A <+> B|"
+proof-
+  have "Inr ` B \<le> A <+> B" by auto
+  thus ?thesis using inj_Inr[of B] card_of_ordLeq by blast
+qed
+
+
+corollary Card_order_Plus2:
+"Card_order r \<Longrightarrow> r \<le>o |A <+> (Field r)|"
+using card_of_Plus2 card_of_Field_ordIso ordIso_ordLeq_trans ordIso_symmetric by blast
+
+
+lemma card_of_Plus_empty1: "|A| =o |A <+> {}|"
+proof-
+  have "bij_betw Inl A (A <+> {})" unfolding bij_betw_def inj_on_def by auto
+  thus ?thesis using card_of_ordIso by auto
+qed
+
+
+lemma card_of_Plus_empty2: "|A| =o |{} <+> A|"
+proof-
+  have "bij_betw Inr A ({} <+> A)" unfolding bij_betw_def inj_on_def by auto
+  thus ?thesis using card_of_ordIso by auto
+qed
+
+
+lemma card_of_Plus_commute: "|A <+> B| =o |B <+> A|"
+proof-
+  let ?f = "\<lambda>(c::'a + 'b). case c of Inl a \<Rightarrow> Inr a
+                                   | Inr b \<Rightarrow> Inl b"
+  have "bij_betw ?f (A <+> B) (B <+> A)"
+  unfolding bij_betw_def inj_on_def by force
+  thus ?thesis using card_of_ordIso by blast
+qed
+
+
+lemma card_of_Plus_assoc:
+fixes A :: "'a set" and B :: "'b set" and C :: "'c set"
+shows "|(A <+> B) <+> C| =o |A <+> B <+> C|"
+proof -
+  def f \<equiv> "\<lambda>(k::('a + 'b) + 'c).
+  case k of Inl ab \<Rightarrow> (case ab of Inl a \<Rightarrow> Inl a
+                                 |Inr b \<Rightarrow> Inr (Inl b))
+           |Inr c \<Rightarrow> Inr (Inr c)"
+  have "A <+> B <+> C \<subseteq> f ` ((A <+> B) <+> C)"
+  proof
+    fix x assume x: "x \<in> A <+> B <+> C"
+    show "x \<in> f ` ((A <+> B) <+> C)"
+    proof(cases x)
+      case (Inl a)
+      hence "a \<in> A" "x = f (Inl (Inl a))"
+      using x unfolding f_def by auto
+      thus ?thesis by auto
+    next
+      case (Inr bc) note 1 = Inr show ?thesis
+      proof(cases bc)
+        case (Inl b)
+        hence "b \<in> B" "x = f (Inl (Inr b))"
+        using x 1 unfolding f_def by auto
+        thus ?thesis by auto
+      next
+        case (Inr c)
+        hence "c \<in> C" "x = f (Inr c)"
+        using x 1 unfolding f_def by auto
+        thus ?thesis by auto
+      qed
+    qed
+  qed
+  hence "bij_betw f ((A <+> B) <+> C) (A <+> B <+> C)"
+  unfolding bij_betw_def inj_on_def f_def by fastforce
+  thus ?thesis using card_of_ordIso by blast
+qed
+
+
+lemma card_of_Plus_mono1:
+assumes "|A| \<le>o |B|"
+shows "|A <+> C| \<le>o |B <+> C|"
+proof-
+  obtain f where 1: "inj_on f A \<and> f ` A \<le> B"
+  using assms card_of_ordLeq[of A] by fastforce
+  obtain g where g_def:
+  "g = (\<lambda>d. case d of Inl a \<Rightarrow> Inl(f a) | Inr (c::'c) \<Rightarrow> Inr c)" by blast
+  have "inj_on g (A <+> C) \<and> g ` (A <+> C) \<le> (B <+> C)"
+  proof-
+    {fix d1 and d2 assume "d1 \<in> A <+> C \<and> d2 \<in> A <+> C" and
+                          "g d1 = g d2"
+     hence "d1 = d2" using 1 unfolding inj_on_def g_def by force
+    }
+    moreover
+    {fix d assume "d \<in> A <+> C"
+     hence "g d \<in> B <+> C"  using 1
+     by(case_tac d, auto simp add: g_def)
+    }
+    ultimately show ?thesis unfolding inj_on_def by auto
+  qed
+  thus ?thesis using card_of_ordLeq by metis
+qed
+
+
+corollary ordLeq_Plus_mono1:
+assumes "r \<le>o r'"
+shows "|(Field r) <+> C| \<le>o |(Field r') <+> C|"
+using assms card_of_mono2 card_of_Plus_mono1 by blast
+
+
+lemma card_of_Plus_mono2:
+assumes "|A| \<le>o |B|"
+shows "|C <+> A| \<le>o |C <+> B|"
+using assms card_of_Plus_mono1[of A B C]
+      card_of_Plus_commute[of C A]  card_of_Plus_commute[of B C]
+      ordIso_ordLeq_trans[of "|C <+> A|"] ordLeq_ordIso_trans[of "|C <+> A|"]
+by blast
+
+
+corollary ordLeq_Plus_mono2:
+assumes "r \<le>o r'"
+shows "|A <+> (Field r)| \<le>o |A <+> (Field r')|"
+using assms card_of_mono2 card_of_Plus_mono2 by blast
+
+
+lemma card_of_Plus_mono:
+assumes "|A| \<le>o |B|" and "|C| \<le>o |D|"
+shows "|A <+> C| \<le>o |B <+> D|"
+using assms card_of_Plus_mono1[of A B C] card_of_Plus_mono2[of C D B]
+      ordLeq_transitive[of "|A <+> C|"] by blast
+
+
+corollary ordLeq_Plus_mono:
+assumes "r \<le>o r'" and "p \<le>o p'"
+shows "|(Field r) <+> (Field p)| \<le>o |(Field r') <+> (Field p')|"
+using assms card_of_mono2[of r r'] card_of_mono2[of p p'] card_of_Plus_mono by blast
+
+
+lemma card_of_Plus_cong1:
+assumes "|A| =o |B|"
+shows "|A <+> C| =o |B <+> C|"
+using assms by (simp add: ordIso_iff_ordLeq card_of_Plus_mono1)
+
+
+corollary ordIso_Plus_cong1:
+assumes "r =o r'"
+shows "|(Field r) <+> C| =o |(Field r') <+> C|"
+using assms card_of_cong card_of_Plus_cong1 by blast
+
+
+lemma card_of_Plus_cong2:
+assumes "|A| =o |B|"
+shows "|C <+> A| =o |C <+> B|"
+using assms by (simp add: ordIso_iff_ordLeq card_of_Plus_mono2)
+
+
+corollary ordIso_Plus_cong2:
+assumes "r =o r'"
+shows "|A <+> (Field r)| =o |A <+> (Field r')|"
+using assms card_of_cong card_of_Plus_cong2 by blast
+
+
+lemma card_of_Plus_cong:
+assumes "|A| =o |B|" and "|C| =o |D|"
+shows "|A <+> C| =o |B <+> D|"
+using assms by (simp add: ordIso_iff_ordLeq card_of_Plus_mono)
+
+
+corollary ordIso_Plus_cong:
+assumes "r =o r'" and "p =o p'"
+shows "|(Field r) <+> (Field p)| =o |(Field r') <+> (Field p')|"
+using assms card_of_cong[of r r'] card_of_cong[of p p'] card_of_Plus_cong by blast
+
+
+lemma card_of_Un_Plus_ordLeq:
+"|A \<union> B| \<le>o |A <+> B|"
+proof-
+   let ?f = "\<lambda> c. if c \<in> A then Inl c else Inr c"
+   have "inj_on ?f (A \<union> B) \<and> ?f ` (A \<union> B) \<le> A <+> B"
+   unfolding inj_on_def by auto
+   thus ?thesis using card_of_ordLeq by blast
+qed
+
+
+lemma card_of_Times1:
+assumes "A \<noteq> {}"
+shows "|B| \<le>o |B \<times> A|"
+proof(cases "B = {}", simp add: card_of_empty)
+  assume *: "B \<noteq> {}"
+  have "fst `(B \<times> A) = B" unfolding image_def using assms by auto
+  thus ?thesis using inj_on_iff_surj[of B "B \<times> A"]
+                     card_of_ordLeq[of B "B \<times> A"] * by blast
+qed
+
+
+lemma card_of_Times_commute: "|A \<times> B| =o |B \<times> A|"
+proof-
+  let ?f = "\<lambda>(a::'a,b::'b). (b,a)"
+  have "bij_betw ?f (A \<times> B) (B \<times> A)"
+  unfolding bij_betw_def inj_on_def by auto
+  thus ?thesis using card_of_ordIso by blast
+qed
+
+
+lemma card_of_Times2:
+assumes "A \<noteq> {}"   shows "|B| \<le>o |A \<times> B|"
+using assms card_of_Times1[of A B] card_of_Times_commute[of B A]
+      ordLeq_ordIso_trans by blast
+
+
+corollary Card_order_Times1:
+"\<lbrakk>Card_order r; B \<noteq> {}\<rbrakk> \<Longrightarrow> r \<le>o |(Field r) \<times> B|"
+using card_of_Times1[of B] card_of_Field_ordIso
+      ordIso_ordLeq_trans ordIso_symmetric by blast
+
+
+corollary Card_order_Times2:
+"\<lbrakk>Card_order r; A \<noteq> {}\<rbrakk> \<Longrightarrow> r \<le>o |A \<times> (Field r)|"
+using card_of_Times2[of A] card_of_Field_ordIso
+      ordIso_ordLeq_trans ordIso_symmetric by blast
+
+
+lemma card_of_Times3: "|A| \<le>o |A \<times> A|"
+using card_of_Times1[of A]
+by(cases "A = {}", simp add: card_of_empty, blast)
+
+
+lemma card_of_Plus_Times_bool: "|A <+> A| =o |A \<times> (UNIV::bool set)|"
+proof-
+  let ?f = "\<lambda>c::'a + 'a. case c of Inl a \<Rightarrow> (a,True)
+                                  |Inr a \<Rightarrow> (a,False)"
+  have "bij_betw ?f (A <+> A) (A \<times> (UNIV::bool set))"
+  proof-
+    {fix  c1 and c2 assume "?f c1 = ?f c2"
+     hence "c1 = c2"
+     by(case_tac "c1", case_tac "c2", auto, case_tac "c2", auto)
+    }
+    moreover
+    {fix c assume "c \<in> A <+> A"
+     hence "?f c \<in> A \<times> (UNIV::bool set)"
+     by(case_tac c, auto)
+    }
+    moreover
+    {fix a bl assume *: "(a,bl) \<in> A \<times> (UNIV::bool set)"
+     have "(a,bl) \<in> ?f ` ( A <+> A)"
+     proof(cases bl)
+       assume bl hence "?f(Inl a) = (a,bl)" by auto
+       thus ?thesis using * by force
+     next
+       assume "\<not> bl" hence "?f(Inr a) = (a,bl)" by auto
+       thus ?thesis using * by force
+     qed
+    }
+    ultimately show ?thesis unfolding bij_betw_def inj_on_def by auto
+  qed
+  thus ?thesis using card_of_ordIso by blast
+qed
+
+
+lemma card_of_Times_mono1:
+assumes "|A| \<le>o |B|"
+shows "|A \<times> C| \<le>o |B \<times> C|"
+proof-
+  obtain f where 1: "inj_on f A \<and> f ` A \<le> B"
+  using assms card_of_ordLeq[of A] by fastforce
+  obtain g where g_def:
+  "g = (\<lambda>(a,c::'c). (f a,c))" by blast
+  have "inj_on g (A \<times> C) \<and> g ` (A \<times> C) \<le> (B \<times> C)"
+  using 1 unfolding inj_on_def using g_def by auto
+  thus ?thesis using card_of_ordLeq by metis
+qed
+
+
+corollary ordLeq_Times_mono1:
+assumes "r \<le>o r'"
+shows "|(Field r) \<times> C| \<le>o |(Field r') \<times> C|"
+using assms card_of_mono2 card_of_Times_mono1 by blast
+
+
+lemma card_of_Times_mono2:
+assumes "|A| \<le>o |B|"
+shows "|C \<times> A| \<le>o |C \<times> B|"
+using assms card_of_Times_mono1[of A B C]
+      card_of_Times_commute[of C A]  card_of_Times_commute[of B C]
+      ordIso_ordLeq_trans[of "|C \<times> A|"] ordLeq_ordIso_trans[of "|C \<times> A|"]
+by blast
+
+
+corollary ordLeq_Times_mono2:
+assumes "r \<le>o r'"
+shows "|A \<times> (Field r)| \<le>o |A \<times> (Field r')|"
+using assms card_of_mono2 card_of_Times_mono2 by blast
+
+
+lemma card_of_Sigma_mono1:
+assumes "\<forall>i \<in> I. |A i| \<le>o |B i|"
+shows "|SIGMA i : I. A i| \<le>o |SIGMA i : I. B i|"
+proof-
+  have "\<forall>i. i \<in> I \<longrightarrow> (\<exists>f. inj_on f (A i) \<and> f ` (A i) \<le> B i)"
+  using assms by (auto simp add: card_of_ordLeq)
+  with choice[of "\<lambda> i f. i \<in> I \<longrightarrow> inj_on f (A i) \<and> f ` (A i) \<le> B i"]
+  obtain F where 1: "\<forall>i \<in> I. inj_on (F i) (A i) \<and> (F i) ` (A i) \<le> B i" by metis
+  obtain g where g_def: "g = (\<lambda>(i,a::'b). (i,F i a))" by blast
+  have "inj_on g (Sigma I A) \<and> g ` (Sigma I A) \<le> (Sigma I B)"
+  using 1 unfolding inj_on_def using g_def by force
+  thus ?thesis using card_of_ordLeq by metis
+qed
+
+
+corollary card_of_Sigma_Times:
+"\<forall>i \<in> I. |A i| \<le>o |B| \<Longrightarrow> |SIGMA i : I. A i| \<le>o |I \<times> B|"
+using card_of_Sigma_mono1[of I A "\<lambda>i. B"] .
+
+
+lemma card_of_UNION_Sigma:
+"|\<Union>i \<in> I. A i| \<le>o |SIGMA i : I. A i|"
+using Ex_inj_on_UNION_Sigma[of I A] card_of_ordLeq by metis
+
+
+lemma card_of_bool:
+assumes "a1 \<noteq> a2"
+shows "|UNIV::bool set| =o |{a1,a2}|"
+proof-
+  let ?f = "\<lambda> bl. case bl of True \<Rightarrow> a1 | False \<Rightarrow> a2"
+  have "bij_betw ?f UNIV {a1,a2}"
+  proof-
+    {fix bl1 and bl2 assume "?f  bl1 = ?f bl2"
+     hence "bl1 = bl2" using assms by (case_tac bl1, case_tac bl2, auto)
+    }
+    moreover
+    {fix bl have "?f bl \<in> {a1,a2}" by (case_tac bl, auto)
+    }
+    moreover
+    {fix a assume *: "a \<in> {a1,a2}"
+     have "a \<in> ?f ` UNIV"
+     proof(cases "a = a1")
+       assume "a = a1"
+       hence "?f True = a" by auto  thus ?thesis by blast
+     next
+       assume "a \<noteq> a1" hence "a = a2" using * by auto
+       hence "?f False = a" by auto  thus ?thesis by blast
+     qed
+    }
+    ultimately show ?thesis unfolding bij_betw_def inj_on_def
+    by (metis image_subsetI order_eq_iff subsetI)
+  qed
+  thus ?thesis using card_of_ordIso by blast
+qed
+
+
+lemma card_of_Plus_Times_aux:
+assumes A2: "a1 \<noteq> a2 \<and> {a1,a2} \<le> A" and
+        LEQ: "|A| \<le>o |B|"
+shows "|A <+> B| \<le>o |A \<times> B|"
+proof-
+  have 1: "|UNIV::bool set| \<le>o |A|"
+  using A2 card_of_mono1[of "{a1,a2}"] card_of_bool[of a1 a2]
+        ordIso_ordLeq_trans[of "|UNIV::bool set|"] by metis
+  (*  *)
+  have "|A <+> B| \<le>o |B <+> B|"
+  using LEQ card_of_Plus_mono1 by blast
+  moreover have "|B <+> B| =o |B \<times> (UNIV::bool set)|"
+  using card_of_Plus_Times_bool by blast
+  moreover have "|B \<times> (UNIV::bool set)| \<le>o |B \<times> A|"
+  using 1 by (simp add: card_of_Times_mono2)
+  moreover have " |B \<times> A| =o |A \<times> B|"
+  using card_of_Times_commute by blast
+  ultimately show "|A <+> B| \<le>o |A \<times> B|"
+  using ordLeq_ordIso_trans[of "|A <+> B|" "|B <+> B|" "|B \<times> (UNIV::bool set)|"]
+        ordLeq_transitive[of "|A <+> B|" "|B \<times> (UNIV::bool set)|" "|B \<times> A|"]
+        ordLeq_ordIso_trans[of "|A <+> B|" "|B \<times> A|" "|A \<times> B|"]
+  by blast
+qed
+
+
+lemma card_of_Plus_Times:
+assumes A2: "a1 \<noteq> a2 \<and> {a1,a2} \<le> A" and
+        B2: "b1 \<noteq> b2 \<and> {b1,b2} \<le> B"
+shows "|A <+> B| \<le>o |A \<times> B|"
+proof-
+  {assume "|A| \<le>o |B|"
+   hence ?thesis using assms by (auto simp add: card_of_Plus_Times_aux)
+  }
+  moreover
+  {assume "|B| \<le>o |A|"
+   hence "|B <+> A| \<le>o |B \<times> A|"
+   using assms by (auto simp add: card_of_Plus_Times_aux)
+   hence ?thesis
+   using card_of_Plus_commute card_of_Times_commute
+         ordIso_ordLeq_trans ordLeq_ordIso_trans by metis
+  }
+  ultimately show ?thesis
+  using card_of_Well_order[of A] card_of_Well_order[of B]
+        ordLeq_total[of "|A|"] by metis
+qed
+
+
+lemma card_of_ordLeq_finite:
+assumes "|A| \<le>o |B|" and "finite B"
+shows "finite A"
+using assms unfolding ordLeq_def
+using embed_inj_on[of "|A|" "|B|"]  embed_Field[of "|A|" "|B|"]
+      Field_card_of[of "A"] Field_card_of[of "B"] inj_on_finite[of _ "A" "B"] by fastforce
+
+
+lemma card_of_ordLeq_infinite:
+assumes "|A| \<le>o |B|" and "\<not> finite A"
+shows "\<not> finite B"
+using assms card_of_ordLeq_finite by auto
+
+
+lemma card_of_ordIso_finite:
+assumes "|A| =o |B|"
+shows "finite A = finite B"
+using assms unfolding ordIso_def iso_def[abs_def]
+by (auto simp: bij_betw_finite Field_card_of)
+
+
+lemma card_of_ordIso_finite_Field:
+assumes "Card_order r" and "r =o |A|"
+shows "finite(Field r) = finite A"
+using assms card_of_Field_ordIso card_of_ordIso_finite ordIso_equivalence by blast
+
+
+subsection {* Cardinals versus set operations involving infinite sets *}
+
+
+text{* Here we show that, for infinite sets, most set-theoretic constructions
+do not increase the cardinality.  The cornerstone for this is
+theorem @{text "Card_order_Times_same_infinite"}, which states that self-product
+does not increase cardinality -- the proof of this fact adapts a standard
+set-theoretic argument, as presented, e.g., in the proof of theorem 1.5.11
+at page 47 in \cite{card-book}. Then everything else follows fairly easily.  *}
+
+
+lemma infinite_iff_card_of_nat:
+"\<not> finite A \<longleftrightarrow> ( |UNIV::nat set| \<le>o |A| )"
+unfolding infinite_iff_countable_subset card_of_ordLeq ..
+
+text{* The next two results correspond to the ZF fact that all infinite cardinals are
+limit ordinals: *}
+
+lemma Card_order_infinite_not_under:
+assumes CARD: "Card_order r" and INF: "\<not>finite (Field r)"
+shows "\<not> (\<exists>a. Field r = under r a)"
+proof(auto)
+  have 0: "Well_order r \<and> wo_rel r \<and> Refl r"
+  using CARD unfolding wo_rel_def card_order_on_def order_on_defs by auto
+  fix a assume *: "Field r = under r a"
+  show False
+  proof(cases "a \<in> Field r")
+    assume Case1: "a \<notin> Field r"
+    hence "under r a = {}" unfolding Field_def under_def by auto
+    thus False using INF *  by auto
+  next
+    let ?r' = "Restr r (underS r a)"
+    assume Case2: "a \<in> Field r"
+    hence 1: "under r a = underS r a \<union> {a} \<and> a \<notin> underS r a"
+    using 0 Refl_under_underS underS_notIn by metis
+    have 2: "wo_rel.ofilter r (underS r a) \<and> underS r a < Field r"
+    using 0 wo_rel.underS_ofilter * 1 Case2 by fast
+    hence "?r' <o r" using 0 using ofilter_ordLess by blast
+    moreover
+    have "Field ?r' = underS r a \<and> Well_order ?r'"
+    using  2 0 Field_Restr_ofilter[of r] Well_order_Restr[of r] by blast
+    ultimately have "|underS r a| <o r" using ordLess_Field[of ?r'] by auto
+    moreover have "|under r a| =o r" using * CARD card_of_Field_ordIso[of r] by auto
+    ultimately have "|underS r a| <o |under r a|"
+    using ordIso_symmetric ordLess_ordIso_trans by blast
+    moreover
+    {have "\<exists>f. bij_betw f (under r a) (underS r a)"
+     using infinite_imp_bij_betw[of "Field r" a] INF * 1 by auto
+     hence "|under r a| =o |underS r a|" using card_of_ordIso by blast
+    }
+    ultimately show False using not_ordLess_ordIso ordIso_symmetric by blast
+  qed
+qed
+
+
+lemma infinite_Card_order_limit:
+assumes r: "Card_order r" and "\<not>finite (Field r)"
+and a: "a : Field r"
+shows "EX b : Field r. a \<noteq> b \<and> (a,b) : r"
+proof-
+  have "Field r \<noteq> under r a"
+  using assms Card_order_infinite_not_under by blast
+  moreover have "under r a \<le> Field r"
+  using under_Field .
+  ultimately have "under r a < Field r" by blast
+  then obtain b where 1: "b : Field r \<and> ~ (b,a) : r"
+  unfolding under_def by blast
+  moreover have ba: "b \<noteq> a"
+  using 1 r unfolding card_order_on_def well_order_on_def
+  linear_order_on_def partial_order_on_def preorder_on_def refl_on_def by auto
+  ultimately have "(a,b) : r"
+  using a r unfolding card_order_on_def well_order_on_def linear_order_on_def
+  total_on_def by blast
+  thus ?thesis using 1 ba by auto
+qed
+
+
+theorem Card_order_Times_same_infinite:
+assumes CO: "Card_order r" and INF: "\<not>finite(Field r)"
+shows "|Field r \<times> Field r| \<le>o r"
+proof-
+  obtain phi where phi_def:
+  "phi = (\<lambda>r::'a rel. Card_order r \<and> \<not>finite(Field r) \<and>
+                      \<not> |Field r \<times> Field r| \<le>o r )" by blast
+  have temp1: "\<forall>r. phi r \<longrightarrow> Well_order r"
+  unfolding phi_def card_order_on_def by auto
+  have Ft: "\<not>(\<exists>r. phi r)"
+  proof
+    assume "\<exists>r. phi r"
+    hence "{r. phi r} \<noteq> {} \<and> {r. phi r} \<le> {r. Well_order r}"
+    using temp1 by auto
+    then obtain r where 1: "phi r" and 2: "\<forall>r'. phi r' \<longrightarrow> r \<le>o r'" and
+                   3: "Card_order r \<and> Well_order r"
+    using exists_minim_Well_order[of "{r. phi r}"] temp1 phi_def by blast
+    let ?A = "Field r"  let ?r' = "bsqr r"
+    have 4: "Well_order ?r' \<and> Field ?r' = ?A \<times> ?A \<and> |?A| =o r"
+    using 3 bsqr_Well_order Field_bsqr card_of_Field_ordIso by blast
+    have 5: "Card_order |?A \<times> ?A| \<and> Well_order |?A \<times> ?A|"
+    using card_of_Card_order card_of_Well_order by blast
+    (*  *)
+    have "r <o |?A \<times> ?A|"
+    using 1 3 5 ordLess_or_ordLeq unfolding phi_def by blast
+    moreover have "|?A \<times> ?A| \<le>o ?r'"
+    using card_of_least[of "?A \<times> ?A"] 4 by auto
+    ultimately have "r <o ?r'" using ordLess_ordLeq_trans by auto
+    then obtain f where 6: "embed r ?r' f" and 7: "\<not> bij_betw f ?A (?A \<times> ?A)"
+    unfolding ordLess_def embedS_def[abs_def]
+    by (auto simp add: Field_bsqr)
+    let ?B = "f ` ?A"
+    have "|?A| =o |?B|"
+    using 3 6 embed_inj_on inj_on_imp_bij_betw card_of_ordIso by blast
+    hence 8: "r =o |?B|" using 4 ordIso_transitive ordIso_symmetric by blast
+    (*  *)
+    have "wo_rel.ofilter ?r' ?B"
+    using 6 embed_Field_ofilter 3 4 by blast
+    hence "wo_rel.ofilter ?r' ?B \<and> ?B \<noteq> ?A \<times> ?A \<and> ?B \<noteq> Field ?r'"
+    using 7 unfolding bij_betw_def using 6 3 embed_inj_on 4 by auto
+    hence temp2: "wo_rel.ofilter ?r' ?B \<and> ?B < ?A \<times> ?A"
+    using 4 wo_rel_def[of ?r'] wo_rel.ofilter_def[of ?r' ?B] by blast
+    have "\<not> (\<exists>a. Field r = under r a)"
+    using 1 unfolding phi_def using Card_order_infinite_not_under[of r] by auto
+    then obtain A1 where temp3: "wo_rel.ofilter r A1 \<and> A1 < ?A" and 9: "?B \<le> A1 \<times> A1"
+    using temp2 3 bsqr_ofilter[of r ?B] by blast
+    hence "|?B| \<le>o |A1 \<times> A1|" using card_of_mono1 by blast
+    hence 10: "r \<le>o |A1 \<times> A1|" using 8 ordIso_ordLeq_trans by blast
+    let ?r1 = "Restr r A1"
+    have "?r1 <o r" using temp3 ofilter_ordLess 3 by blast
+    moreover
+    {have "well_order_on A1 ?r1" using 3 temp3 well_order_on_Restr by blast
+     hence "|A1| \<le>o ?r1" using 3 Well_order_Restr card_of_least by blast
+    }
+    ultimately have 11: "|A1| <o r" using ordLeq_ordLess_trans by blast
+    (*  *)
+    have "\<not> finite (Field r)" using 1 unfolding phi_def by simp
+    hence "\<not> finite ?B" using 8 3 card_of_ordIso_finite_Field[of r ?B] by blast
+    hence "\<not> finite A1" using 9 finite_cartesian_product finite_subset by metis
+    moreover have temp4: "Field |A1| = A1 \<and> Well_order |A1| \<and> Card_order |A1|"
+    using card_of_Card_order[of A1] card_of_Well_order[of A1]
+    by (simp add: Field_card_of)
+    moreover have "\<not> r \<le>o | A1 |"
+    using temp4 11 3 using not_ordLeq_iff_ordLess by blast
+    ultimately have "\<not> finite(Field |A1| ) \<and> Card_order |A1| \<and> \<not> r \<le>o | A1 |"
+    by (simp add: card_of_card_order_on)
+    hence "|Field |A1| \<times> Field |A1| | \<le>o |A1|"
+    using 2 unfolding phi_def by blast
+    hence "|A1 \<times> A1 | \<le>o |A1|" using temp4 by auto
+    hence "r \<le>o |A1|" using 10 ordLeq_transitive by blast
+    thus False using 11 not_ordLess_ordLeq by auto
+  qed
+  thus ?thesis using assms unfolding phi_def by blast
+qed
+
+
+corollary card_of_Times_same_infinite:
+assumes "\<not>finite A"
+shows "|A \<times> A| =o |A|"
+proof-
+  let ?r = "|A|"
+  have "Field ?r = A \<and> Card_order ?r"
+  using Field_card_of card_of_Card_order[of A] by fastforce
+  hence "|A \<times> A| \<le>o |A|"
+  using Card_order_Times_same_infinite[of ?r] assms by auto
+  thus ?thesis using card_of_Times3 ordIso_iff_ordLeq by blast
+qed
+
+
+lemma card_of_Times_infinite:
+assumes INF: "\<not>finite A" and NE: "B \<noteq> {}" and LEQ: "|B| \<le>o |A|"
+shows "|A \<times> B| =o |A| \<and> |B \<times> A| =o |A|"
+proof-
+  have "|A| \<le>o |A \<times> B| \<and> |A| \<le>o |B \<times> A|"
+  using assms by (simp add: card_of_Times1 card_of_Times2)
+  moreover
+  {have "|A \<times> B| \<le>o |A \<times> A| \<and> |B \<times> A| \<le>o |A \<times> A|"
+   using LEQ card_of_Times_mono1 card_of_Times_mono2 by blast
+   moreover have "|A \<times> A| =o |A|" using INF card_of_Times_same_infinite by blast
+   ultimately have "|A \<times> B| \<le>o |A| \<and> |B \<times> A| \<le>o |A|"
+   using ordLeq_ordIso_trans[of "|A \<times> B|"] ordLeq_ordIso_trans[of "|B \<times> A|"] by auto
+  }
+  ultimately show ?thesis by (simp add: ordIso_iff_ordLeq)
+qed
+
+
+corollary Card_order_Times_infinite:
+assumes INF: "\<not>finite(Field r)" and CARD: "Card_order r" and
+        NE: "Field p \<noteq> {}" and LEQ: "p \<le>o r"
+shows "| (Field r) \<times> (Field p) | =o r \<and> | (Field p) \<times> (Field r) | =o r"
+proof-
+  have "|Field r \<times> Field p| =o |Field r| \<and> |Field p \<times> Field r| =o |Field r|"
+  using assms by (simp add: card_of_Times_infinite card_of_mono2)
+  thus ?thesis
+  using assms card_of_Field_ordIso[of r]
+        ordIso_transitive[of "|Field r \<times> Field p|"]
+        ordIso_transitive[of _ "|Field r|"] by blast
+qed
+
+
+lemma card_of_Sigma_ordLeq_infinite:
+assumes INF: "\<not>finite B" and
+        LEQ_I: "|I| \<le>o |B|" and LEQ: "\<forall>i \<in> I. |A i| \<le>o |B|"
+shows "|SIGMA i : I. A i| \<le>o |B|"
+proof(cases "I = {}", simp add: card_of_empty)
+  assume *: "I \<noteq> {}"
+  have "|SIGMA i : I. A i| \<le>o |I \<times> B|"
+  using LEQ card_of_Sigma_Times by blast
+  moreover have "|I \<times> B| =o |B|"
+  using INF * LEQ_I by (auto simp add: card_of_Times_infinite)
+  ultimately show ?thesis using ordLeq_ordIso_trans by blast
+qed
+
+
+lemma card_of_Sigma_ordLeq_infinite_Field:
+assumes INF: "\<not>finite (Field r)" and r: "Card_order r" and
+        LEQ_I: "|I| \<le>o r" and LEQ: "\<forall>i \<in> I. |A i| \<le>o r"
+shows "|SIGMA i : I. A i| \<le>o r"
+proof-
+  let ?B  = "Field r"
+  have 1: "r =o |?B| \<and> |?B| =o r" using r card_of_Field_ordIso
+  ordIso_symmetric by blast
+  hence "|I| \<le>o |?B|"  "\<forall>i \<in> I. |A i| \<le>o |?B|"
+  using LEQ_I LEQ ordLeq_ordIso_trans by blast+
+  hence  "|SIGMA i : I. A i| \<le>o |?B|" using INF LEQ
+  card_of_Sigma_ordLeq_infinite by blast
+  thus ?thesis using 1 ordLeq_ordIso_trans by blast
+qed
+
+
+lemma card_of_Times_ordLeq_infinite_Field:
+"\<lbrakk>\<not>finite (Field r); |A| \<le>o r; |B| \<le>o r; Card_order r\<rbrakk>
+ \<Longrightarrow> |A <*> B| \<le>o r"
+by(simp add: card_of_Sigma_ordLeq_infinite_Field)
+
+
+lemma card_of_Times_infinite_simps:
+"\<lbrakk>\<not>finite A; B \<noteq> {}; |B| \<le>o |A|\<rbrakk> \<Longrightarrow> |A \<times> B| =o |A|"
+"\<lbrakk>\<not>finite A; B \<noteq> {}; |B| \<le>o |A|\<rbrakk> \<Longrightarrow> |A| =o |A \<times> B|"
+"\<lbrakk>\<not>finite A; B \<noteq> {}; |B| \<le>o |A|\<rbrakk> \<Longrightarrow> |B \<times> A| =o |A|"
+"\<lbrakk>\<not>finite A; B \<noteq> {}; |B| \<le>o |A|\<rbrakk> \<Longrightarrow> |A| =o |B \<times> A|"
+by (auto simp add: card_of_Times_infinite ordIso_symmetric)
+
+
+lemma card_of_UNION_ordLeq_infinite:
+assumes INF: "\<not>finite B" and
+        LEQ_I: "|I| \<le>o |B|" and LEQ: "\<forall>i \<in> I. |A i| \<le>o |B|"
+shows "|\<Union> i \<in> I. A i| \<le>o |B|"
+proof(cases "I = {}", simp add: card_of_empty)
+  assume *: "I \<noteq> {}"
+  have "|\<Union> i \<in> I. A i| \<le>o |SIGMA i : I. A i|"
+  using card_of_UNION_Sigma by blast
+  moreover have "|SIGMA i : I. A i| \<le>o |B|"
+  using assms card_of_Sigma_ordLeq_infinite by blast
+  ultimately show ?thesis using ordLeq_transitive by blast
+qed
+
+
+corollary card_of_UNION_ordLeq_infinite_Field:
+assumes INF: "\<not>finite (Field r)" and r: "Card_order r" and
+        LEQ_I: "|I| \<le>o r" and LEQ: "\<forall>i \<in> I. |A i| \<le>o r"
+shows "|\<Union> i \<in> I. A i| \<le>o r"
+proof-
+  let ?B  = "Field r"
+  have 1: "r =o |?B| \<and> |?B| =o r" using r card_of_Field_ordIso
+  ordIso_symmetric by blast
+  hence "|I| \<le>o |?B|"  "\<forall>i \<in> I. |A i| \<le>o |?B|"
+  using LEQ_I LEQ ordLeq_ordIso_trans by blast+
+  hence  "|\<Union> i \<in> I. A i| \<le>o |?B|" using INF LEQ
+  card_of_UNION_ordLeq_infinite by blast
+  thus ?thesis using 1 ordLeq_ordIso_trans by blast
+qed
+
+
+lemma card_of_Plus_infinite1:
+assumes INF: "\<not>finite A" and LEQ: "|B| \<le>o |A|"
+shows "|A <+> B| =o |A|"
+proof(cases "B = {}", simp add: card_of_Plus_empty1 card_of_Plus_empty2 ordIso_symmetric)
+  let ?Inl = "Inl::'a \<Rightarrow> 'a + 'b"  let ?Inr = "Inr::'b \<Rightarrow> 'a + 'b"
+  assume *: "B \<noteq> {}"
+  then obtain b1 where 1: "b1 \<in> B" by blast
+  show ?thesis
+  proof(cases "B = {b1}")
+    assume Case1: "B = {b1}"
+    have 2: "bij_betw ?Inl A ((?Inl ` A))"
+    unfolding bij_betw_def inj_on_def by auto
+    hence 3: "\<not>finite (?Inl ` A)"
+    using INF bij_betw_finite[of ?Inl A] by blast
+    let ?A' = "?Inl ` A \<union> {?Inr b1}"
+    obtain g where "bij_betw g (?Inl ` A) ?A'"
+    using 3 infinite_imp_bij_betw2[of "?Inl ` A"] by auto
+    moreover have "?A' = A <+> B" using Case1 by blast
+    ultimately have "bij_betw g (?Inl ` A) (A <+> B)" by simp
+    hence "bij_betw (g o ?Inl) A (A <+> B)"
+    using 2 by (auto simp add: bij_betw_trans)
+    thus ?thesis using card_of_ordIso ordIso_symmetric by blast
+  next
+    assume Case2: "B \<noteq> {b1}"
+    with * 1 obtain b2 where 3: "b1 \<noteq> b2 \<and> {b1,b2} \<le> B" by fastforce
+    obtain f where "inj_on f B \<and> f ` B \<le> A"
+    using LEQ card_of_ordLeq[of B] by fastforce
+    with 3 have "f b1 \<noteq> f b2 \<and> {f b1, f b2} \<le> A"
+    unfolding inj_on_def by auto
+    with 3 have "|A <+> B| \<le>o |A \<times> B|"
+    by (auto simp add: card_of_Plus_Times)
+    moreover have "|A \<times> B| =o |A|"
+    using assms * by (simp add: card_of_Times_infinite_simps)
+    ultimately have "|A <+> B| \<le>o |A|" using ordLeq_ordIso_trans by metis
+    thus ?thesis using card_of_Plus1 ordIso_iff_ordLeq by blast
+  qed
+qed
+
+
+lemma card_of_Plus_infinite2:
+assumes INF: "\<not>finite A" and LEQ: "|B| \<le>o |A|"
+shows "|B <+> A| =o |A|"
+using assms card_of_Plus_commute card_of_Plus_infinite1
+ordIso_equivalence by blast
+
+
+lemma card_of_Plus_infinite:
+assumes INF: "\<not>finite A" and LEQ: "|B| \<le>o |A|"
+shows "|A <+> B| =o |A| \<and> |B <+> A| =o |A|"
+using assms by (auto simp: card_of_Plus_infinite1 card_of_Plus_infinite2)
+
+
+corollary Card_order_Plus_infinite:
+assumes INF: "\<not>finite(Field r)" and CARD: "Card_order r" and
+        LEQ: "p \<le>o r"
+shows "| (Field r) <+> (Field p) | =o r \<and> | (Field p) <+> (Field r) | =o r"
+proof-
+  have "| Field r <+> Field p | =o | Field r | \<and>
+        | Field p <+> Field r | =o | Field r |"
+  using assms by (simp add: card_of_Plus_infinite card_of_mono2)
+  thus ?thesis
+  using assms card_of_Field_ordIso[of r]
+        ordIso_transitive[of "|Field r <+> Field p|"]
+        ordIso_transitive[of _ "|Field r|"] by blast
+qed
+
+
+subsection {* The cardinal $\omega$ and the finite cardinals  *}
+
+
+text{* The cardinal $\omega$, of natural numbers, shall be the standard non-strict
+order relation on
+@{text "nat"}, that we abbreviate by @{text "natLeq"}.  The finite cardinals
+shall be the restrictions of these relations to the numbers smaller than
+fixed numbers @{text "n"}, that we abbreviate by @{text "natLeq_on n"}.  *}
+
+abbreviation "(natLeq::(nat * nat) set) \<equiv> {(x,y). x \<le> y}"
+abbreviation "(natLess::(nat * nat) set) \<equiv> {(x,y). x < y}"
+
+abbreviation natLeq_on :: "nat \<Rightarrow> (nat * nat) set"
+where "natLeq_on n \<equiv> {(x,y). x < n \<and> y < n \<and> x \<le> y}"
+
+lemma infinite_cartesian_product:
+assumes "\<not>finite A" "\<not>finite B"
+shows "\<not>finite (A \<times> B)"
+proof
+  assume "finite (A \<times> B)"
+  from assms(1) have "A \<noteq> {}" by auto
+  with `finite (A \<times> B)` have "finite B" using finite_cartesian_productD2 by auto
+  with assms(2) show False by simp
+qed
+
+
+subsubsection {* First as well-orders *}
+
+
+lemma Field_natLeq: "Field natLeq = (UNIV::nat set)"
+by(unfold Field_def, auto)
+
+
+lemma natLeq_Refl: "Refl natLeq"
+unfolding refl_on_def Field_def by auto
+
+
+lemma natLeq_trans: "trans natLeq"
+unfolding trans_def by auto
+
+
+lemma natLeq_Preorder: "Preorder natLeq"
+unfolding preorder_on_def
+by (auto simp add: natLeq_Refl natLeq_trans)
+
+
+lemma natLeq_antisym: "antisym natLeq"
+unfolding antisym_def by auto
+
+
+lemma natLeq_Partial_order: "Partial_order natLeq"
+unfolding partial_order_on_def
+by (auto simp add: natLeq_Preorder natLeq_antisym)
+
+
+lemma natLeq_Total: "Total natLeq"
+unfolding total_on_def by auto
+
+
+lemma natLeq_Linear_order: "Linear_order natLeq"
+unfolding linear_order_on_def
+by (auto simp add: natLeq_Partial_order natLeq_Total)
+
+
+lemma natLeq_natLess_Id: "natLess = natLeq - Id"
+by auto
+
+
+lemma natLeq_Well_order: "Well_order natLeq"
+unfolding well_order_on_def
+using natLeq_Linear_order wf_less natLeq_natLess_Id by auto
+
+
+lemma Field_natLeq_on: "Field (natLeq_on n) = {x. x < n}"
+unfolding Field_def by auto
+
+
+lemma natLeq_underS_less: "underS natLeq n = {x. x < n}"
+unfolding underS_def by auto
+
+
+lemma Restr_natLeq: "Restr natLeq {x. x < n} = natLeq_on n"
+by force
+
+
+lemma Restr_natLeq2:
+"Restr natLeq (underS natLeq n) = natLeq_on n"
+by (auto simp add: Restr_natLeq natLeq_underS_less)
+
+
+lemma natLeq_on_Well_order: "Well_order(natLeq_on n)"
+using Restr_natLeq[of n] natLeq_Well_order
+      Well_order_Restr[of natLeq "{x. x < n}"] by auto
+
+
+corollary natLeq_on_well_order_on: "well_order_on {x. x < n} (natLeq_on n)"
+using natLeq_on_Well_order Field_natLeq_on by auto
+
+
+lemma natLeq_on_wo_rel: "wo_rel(natLeq_on n)"
+unfolding wo_rel_def using natLeq_on_Well_order .
+
+
+
+subsubsection {* Then as cardinals *}
+
+
+lemma natLeq_Card_order: "Card_order natLeq"
+proof(auto simp add: natLeq_Well_order
+      Card_order_iff_Restr_underS Restr_natLeq2, simp add:  Field_natLeq)
+  fix n have "finite(Field (natLeq_on n))" by (auto simp: Field_def)
+  moreover have "\<not>finite(UNIV::nat set)" by auto
+  ultimately show "natLeq_on n <o |UNIV::nat set|"
+  using finite_ordLess_infinite[of "natLeq_on n" "|UNIV::nat set|"]
+        Field_card_of[of "UNIV::nat set"]
+        card_of_Well_order[of "UNIV::nat set"] natLeq_on_Well_order[of n] by auto
+qed
+
+
+corollary card_of_Field_natLeq:
+"|Field natLeq| =o natLeq"
+using Field_natLeq natLeq_Card_order Card_order_iff_ordIso_card_of[of natLeq]
+      ordIso_symmetric[of natLeq] by blast
+
+
+corollary card_of_nat:
+"|UNIV::nat set| =o natLeq"
+using Field_natLeq card_of_Field_natLeq by auto
+
+
+corollary infinite_iff_natLeq_ordLeq:
+"\<not>finite A = ( natLeq \<le>o |A| )"
+using infinite_iff_card_of_nat[of A] card_of_nat
+      ordIso_ordLeq_trans ordLeq_ordIso_trans ordIso_symmetric by blast
+
+corollary finite_iff_ordLess_natLeq:
+"finite A = ( |A| <o natLeq)"
+using infinite_iff_natLeq_ordLeq not_ordLeq_iff_ordLess
+      card_of_Well_order natLeq_Well_order by metis
+
+
+subsection {* The successor of a cardinal *}
+
+
+text{* First we define @{text "isCardSuc r r'"}, the notion of @{text "r'"}
+being a successor cardinal of @{text "r"}. Although the definition does
+not require @{text "r"} to be a cardinal, only this case will be meaningful.  *}
+
+
+definition isCardSuc :: "'a rel \<Rightarrow> 'a set rel \<Rightarrow> bool"
+where
+"isCardSuc r r' \<equiv>
+ Card_order r' \<and> r <o r' \<and>
+ (\<forall>(r''::'a set rel). Card_order r'' \<and> r <o r'' \<longrightarrow> r' \<le>o r'')"
+
+
+text{* Now we introduce the cardinal-successor operator @{text "cardSuc"},
+by picking {\em some} cardinal-order relation fulfilling @{text "isCardSuc"}.
+Again, the picked item shall be proved unique up to order-isomorphism. *}
+
+
+definition cardSuc :: "'a rel \<Rightarrow> 'a set rel"
+where
+"cardSuc r \<equiv> SOME r'. isCardSuc r r'"
+
+
+lemma exists_minim_Card_order:
+"\<lbrakk>R \<noteq> {}; \<forall>r \<in> R. Card_order r\<rbrakk> \<Longrightarrow> \<exists>r \<in> R. \<forall>r' \<in> R. r \<le>o r'"
+unfolding card_order_on_def using exists_minim_Well_order by blast
+
+
+lemma exists_isCardSuc:
+assumes "Card_order r"
+shows "\<exists>r'. isCardSuc r r'"
+proof-
+  let ?R = "{(r'::'a set rel). Card_order r' \<and> r <o r'}"
+  have "|Pow(Field r)| \<in> ?R \<and> (\<forall>r \<in> ?R. Card_order r)" using assms
+  by (simp add: card_of_Card_order Card_order_Pow)
+  then obtain r where "r \<in> ?R \<and> (\<forall>r' \<in> ?R. r \<le>o r')"
+  using exists_minim_Card_order[of ?R] by blast
+  thus ?thesis unfolding isCardSuc_def by auto
+qed
+
+
+lemma cardSuc_isCardSuc:
+assumes "Card_order r"
+shows "isCardSuc r (cardSuc r)"
+unfolding cardSuc_def using assms
+by (simp add: exists_isCardSuc someI_ex)
+
+
+lemma cardSuc_Card_order:
+"Card_order r \<Longrightarrow> Card_order(cardSuc r)"
+using cardSuc_isCardSuc unfolding isCardSuc_def by blast
+
+
+lemma cardSuc_greater:
+"Card_order r \<Longrightarrow> r <o cardSuc r"
+using cardSuc_isCardSuc unfolding isCardSuc_def by blast
+
+
+lemma cardSuc_ordLeq:
+"Card_order r \<Longrightarrow> r \<le>o cardSuc r"
+using cardSuc_greater ordLeq_iff_ordLess_or_ordIso by blast
+
+
+text{* The minimality property of @{text "cardSuc"} originally present in its definition
+is local to the type @{text "'a set rel"}, i.e., that of @{text "cardSuc r"}:  *}
+
+lemma cardSuc_least_aux:
+"\<lbrakk>Card_order (r::'a rel); Card_order (r'::'a set rel); r <o r'\<rbrakk> \<Longrightarrow> cardSuc r \<le>o r'"
+using cardSuc_isCardSuc unfolding isCardSuc_def by blast
+
+
+text{* But from this we can infer general minimality: *}
+
+lemma cardSuc_least:
+assumes CARD: "Card_order r" and CARD': "Card_order r'" and LESS: "r <o r'"
+shows "cardSuc r \<le>o r'"
+proof-
+  let ?p = "cardSuc r"
+  have 0: "Well_order ?p \<and> Well_order r'"
+  using assms cardSuc_Card_order unfolding card_order_on_def by blast
+  {assume "r' <o ?p"
+   then obtain r'' where 1: "Field r'' < Field ?p" and 2: "r' =o r'' \<and> r'' <o ?p"
+   using internalize_ordLess[of r' ?p] by blast
+   (*  *)
+   have "Card_order r''" using CARD' Card_order_ordIso2 2 by blast
+   moreover have "r <o r''" using LESS 2 ordLess_ordIso_trans by blast
+   ultimately have "?p \<le>o r''" using cardSuc_least_aux CARD by blast
+   hence False using 2 not_ordLess_ordLeq by blast
+  }
+  thus ?thesis using 0 ordLess_or_ordLeq by blast
+qed
+
+
+lemma cardSuc_ordLess_ordLeq:
+assumes CARD: "Card_order r" and CARD': "Card_order r'"
+shows "(r <o r') = (cardSuc r \<le>o r')"
+proof(auto simp add: assms cardSuc_least)
+  assume "cardSuc r \<le>o r'"
+  thus "r <o r'" using assms cardSuc_greater ordLess_ordLeq_trans by blast
+qed
+
+
+lemma cardSuc_ordLeq_ordLess:
+assumes CARD: "Card_order r" and CARD': "Card_order r'"
+shows "(r' <o cardSuc r) = (r' \<le>o r)"
+proof-
+  have "Well_order r \<and> Well_order r'"
+  using assms unfolding card_order_on_def by auto
+  moreover have "Well_order(cardSuc r)"
+  using assms cardSuc_Card_order card_order_on_def by blast
+  ultimately show ?thesis
+  using assms cardSuc_ordLess_ordLeq[of r r']
+  not_ordLeq_iff_ordLess[of r r'] not_ordLeq_iff_ordLess[of r' "cardSuc r"] by blast
+qed
+
+
+lemma cardSuc_mono_ordLeq:
+assumes CARD: "Card_order r" and CARD': "Card_order r'"
+shows "(cardSuc r \<le>o cardSuc r') = (r \<le>o r')"
+using assms cardSuc_ordLeq_ordLess cardSuc_ordLess_ordLeq cardSuc_Card_order by blast
+
+
+lemma cardSuc_invar_ordIso:
+assumes CARD: "Card_order r" and CARD': "Card_order r'"
+shows "(cardSuc r =o cardSuc r') = (r =o r')"
+proof-
+  have 0: "Well_order r \<and> Well_order r' \<and> Well_order(cardSuc r) \<and> Well_order(cardSuc r')"
+  using assms by (simp add: card_order_on_well_order_on cardSuc_Card_order)
+  thus ?thesis
+  using ordIso_iff_ordLeq[of r r'] ordIso_iff_ordLeq
+  using cardSuc_mono_ordLeq[of r r'] cardSuc_mono_ordLeq[of r' r] assms by blast
+qed
+
+
+lemma card_of_cardSuc_finite:
+"finite(Field(cardSuc |A| )) = finite A"
+proof
+  assume *: "finite (Field (cardSuc |A| ))"
+  have 0: "|Field(cardSuc |A| )| =o cardSuc |A|"
+  using card_of_Card_order cardSuc_Card_order card_of_Field_ordIso by blast
+  hence "|A| \<le>o |Field(cardSuc |A| )|"
+  using card_of_Card_order[of A] cardSuc_ordLeq[of "|A|"] ordIso_symmetric
+  ordLeq_ordIso_trans by blast
+  thus "finite A" using * card_of_ordLeq_finite by blast
+next
+  assume "finite A"
+  then have "finite ( Field |Pow A| )" unfolding Field_card_of by simp
+  then show "finite (Field (cardSuc |A| ))"
+  proof (rule card_of_ordLeq_finite[OF card_of_mono2, rotated])
+    show "cardSuc |A| \<le>o |Pow A|"
+      by (metis cardSuc_ordLess_ordLeq card_of_Card_order card_of_Pow)
+  qed
+qed
+
+
+lemma cardSuc_finite:
+assumes "Card_order r"
+shows "finite (Field (cardSuc r)) = finite (Field r)"
+proof-
+  let ?A = "Field r"
+  have "|?A| =o r" using assms by (simp add: card_of_Field_ordIso)
+  hence "cardSuc |?A| =o cardSuc r" using assms
+  by (simp add: card_of_Card_order cardSuc_invar_ordIso)
+  moreover have "|Field (cardSuc |?A| ) | =o cardSuc |?A|"
+  by (simp add: card_of_card_order_on Field_card_of card_of_Field_ordIso cardSuc_Card_order)
+  moreover
+  {have "|Field (cardSuc r) | =o cardSuc r"
+   using assms by (simp add: card_of_Field_ordIso cardSuc_Card_order)
+   hence "cardSuc r =o |Field (cardSuc r) |"
+   using ordIso_symmetric by blast
+  }
+  ultimately have "|Field (cardSuc |?A| ) | =o |Field (cardSuc r) |"
+  using ordIso_transitive by blast
+  hence "finite (Field (cardSuc |?A| )) = finite (Field (cardSuc r))"
+  using card_of_ordIso_finite by blast
+  thus ?thesis by (simp only: card_of_cardSuc_finite)
+qed
+
+
+lemma card_of_Plus_ordLess_infinite:
+assumes INF: "\<not>finite C" and
+        LESS1: "|A| <o |C|" and LESS2: "|B| <o |C|"
+shows "|A <+> B| <o |C|"
+proof(cases "A = {} \<or> B = {}")
+  assume Case1: "A = {} \<or> B = {}"
+  hence "|A| =o |A <+> B| \<or> |B| =o |A <+> B|"
+  using card_of_Plus_empty1 card_of_Plus_empty2 by blast
+  hence "|A <+> B| =o |A| \<or> |A <+> B| =o |B|"
+  using ordIso_symmetric[of "|A|"] ordIso_symmetric[of "|B|"] by blast
+  thus ?thesis using LESS1 LESS2
+       ordIso_ordLess_trans[of "|A <+> B|" "|A|"]
+       ordIso_ordLess_trans[of "|A <+> B|" "|B|"] by blast
+next
+  assume Case2: "\<not>(A = {} \<or> B = {})"
+  {assume *: "|C| \<le>o |A <+> B|"
+   hence "\<not>finite (A <+> B)" using INF card_of_ordLeq_finite by blast
+   hence 1: "\<not>finite A \<or> \<not>finite B" using finite_Plus by blast
+   {assume Case21: "|A| \<le>o |B|"
+    hence "\<not>finite B" using 1 card_of_ordLeq_finite by blast
+    hence "|A <+> B| =o |B|" using Case2 Case21
+    by (auto simp add: card_of_Plus_infinite)
+    hence False using LESS2 not_ordLess_ordLeq * ordLeq_ordIso_trans by blast
+   }
+   moreover
+   {assume Case22: "|B| \<le>o |A|"
+    hence "\<not>finite A" using 1 card_of_ordLeq_finite by blast
+    hence "|A <+> B| =o |A|" using Case2 Case22
+    by (auto simp add: card_of_Plus_infinite)
+    hence False using LESS1 not_ordLess_ordLeq * ordLeq_ordIso_trans by blast
+   }
+   ultimately have False using ordLeq_total card_of_Well_order[of A]
+   card_of_Well_order[of B] by blast
+  }
+  thus ?thesis using ordLess_or_ordLeq[of "|A <+> B|" "|C|"]
+  card_of_Well_order[of "A <+> B"] card_of_Well_order[of "C"] by auto
+qed
+
+
+lemma card_of_Plus_ordLess_infinite_Field:
+assumes INF: "\<not>finite (Field r)" and r: "Card_order r" and
+        LESS1: "|A| <o r" and LESS2: "|B| <o r"
+shows "|A <+> B| <o r"
+proof-
+  let ?C  = "Field r"
+  have 1: "r =o |?C| \<and> |?C| =o r" using r card_of_Field_ordIso
+  ordIso_symmetric by blast
+  hence "|A| <o |?C|"  "|B| <o |?C|"
+  using LESS1 LESS2 ordLess_ordIso_trans by blast+
+  hence  "|A <+> B| <o |?C|" using INF
+  card_of_Plus_ordLess_infinite by blast
+  thus ?thesis using 1 ordLess_ordIso_trans by blast
+qed
+
+
+lemma card_of_Plus_ordLeq_infinite_Field:
+assumes r: "\<not>finite (Field r)" and A: "|A| \<le>o r" and B: "|B| \<le>o r"
+and c: "Card_order r"
+shows "|A <+> B| \<le>o r"
+proof-
+  let ?r' = "cardSuc r"
+  have "Card_order ?r' \<and> \<not>finite (Field ?r')" using assms
+  by (simp add: cardSuc_Card_order cardSuc_finite)
+  moreover have "|A| <o ?r'" and "|B| <o ?r'" using A B c
+  by (auto simp: card_of_card_order_on Field_card_of cardSuc_ordLeq_ordLess)
+  ultimately have "|A <+> B| <o ?r'"
+  using card_of_Plus_ordLess_infinite_Field by blast
+  thus ?thesis using c r
+  by (simp add: card_of_card_order_on Field_card_of cardSuc_ordLeq_ordLess)
+qed
+
+
+lemma card_of_Un_ordLeq_infinite_Field:
+assumes C: "\<not>finite (Field r)" and A: "|A| \<le>o r" and B: "|B| \<le>o r"
+and "Card_order r"
+shows "|A Un B| \<le>o r"
+using assms card_of_Plus_ordLeq_infinite_Field card_of_Un_Plus_ordLeq
+ordLeq_transitive by fast
+
+
+
+subsection {* Regular cardinals *}
+
+
+definition cofinal where
+"cofinal A r \<equiv>
+ ALL a : Field r. EX b : A. a \<noteq> b \<and> (a,b) : r"
+
+
+definition regular where
+"regular r \<equiv>
+ ALL K. K \<le> Field r \<and> cofinal K r \<longrightarrow> |K| =o r"
+
+
+definition relChain where
+"relChain r As \<equiv>
+ ALL i j. (i,j) \<in> r \<longrightarrow> As i \<le> As j"
+
+lemma regular_UNION:
+assumes r: "Card_order r"   "regular r"
+and As: "relChain r As"
+and Bsub: "B \<le> (UN i : Field r. As i)"
+and cardB: "|B| <o r"
+shows "EX i : Field r. B \<le> As i"
+proof-
+  let ?phi = "%b j. j : Field r \<and> b : As j"
+  have "ALL b : B. EX j. ?phi b j" using Bsub by blast
+  then obtain f where f: "!! b. b : B \<Longrightarrow> ?phi b (f b)"
+  using bchoice[of B ?phi] by blast
+  let ?K = "f ` B"
+  {assume 1: "!! i. i : Field r \<Longrightarrow> ~ B \<le> As i"
+   have 2: "cofinal ?K r"
+   unfolding cofinal_def proof auto
+     fix i assume i: "i : Field r"
+     with 1 obtain b where b: "b : B \<and> b \<notin> As i" by blast
+     hence "i \<noteq> f b \<and> ~ (f b,i) : r"
+     using As f unfolding relChain_def by auto
+     hence "i \<noteq> f b \<and> (i, f b) : r" using r
+     unfolding card_order_on_def well_order_on_def linear_order_on_def
+     total_on_def using i f b by auto
+     with b show "\<exists>b\<in>B. i \<noteq> f b \<and> (i, f b) \<in> r" by blast
+   qed
+   moreover have "?K \<le> Field r" using f by blast
+   ultimately have "|?K| =o r" using 2 r unfolding regular_def by blast
+   moreover
+   {
+    have "|?K| <=o |B|" using card_of_image .
+    hence "|?K| <o r" using cardB ordLeq_ordLess_trans by blast
+   }
+   ultimately have False using not_ordLess_ordIso by blast
+  }
+  thus ?thesis by blast
+qed
+
+
+lemma infinite_cardSuc_regular:
+assumes r_inf: "\<not>finite (Field r)" and r_card: "Card_order r"
+shows "regular (cardSuc r)"
+proof-
+  let ?r' = "cardSuc r"
+  have r': "Card_order ?r'"
+  "!! p. Card_order p \<longrightarrow> (p \<le>o r) = (p <o ?r')"
+  using r_card by (auto simp: cardSuc_Card_order cardSuc_ordLeq_ordLess)
+  show ?thesis
+  unfolding regular_def proof auto
+    fix K assume 1: "K \<le> Field ?r'" and 2: "cofinal K ?r'"
+    hence "|K| \<le>o |Field ?r'|" by (simp only: card_of_mono1)
+    also have 22: "|Field ?r'| =o ?r'"
+    using r' by (simp add: card_of_Field_ordIso[of ?r'])
+    finally have "|K| \<le>o ?r'" .
+    moreover
+    {let ?L = "UN j : K. underS ?r' j"
+     let ?J = "Field r"
+     have rJ: "r =o |?J|"
+     using r_card card_of_Field_ordIso ordIso_symmetric by blast
+     assume "|K| <o ?r'"
+     hence "|K| <=o r" using r' card_of_Card_order[of K] by blast
+     hence "|K| \<le>o |?J|" using rJ ordLeq_ordIso_trans by blast
+     moreover
+     {have "ALL j : K. |underS ?r' j| <o ?r'"
+      using r' 1 by (auto simp: card_of_underS)
+      hence "ALL j : K. |underS ?r' j| \<le>o r"
+      using r' card_of_Card_order by blast
+      hence "ALL j : K. |underS ?r' j| \<le>o |?J|"
+      using rJ ordLeq_ordIso_trans by blast
+     }
+     ultimately have "|?L| \<le>o |?J|"
+     using r_inf card_of_UNION_ordLeq_infinite by blast
+     hence "|?L| \<le>o r" using rJ ordIso_symmetric ordLeq_ordIso_trans by blast
+     hence "|?L| <o ?r'" using r' card_of_Card_order by blast
+     moreover
+     {
+      have "Field ?r' \<le> ?L"
+      using 2 unfolding underS_def cofinal_def by auto
+      hence "|Field ?r'| \<le>o |?L|" by (simp add: card_of_mono1)
+      hence "?r' \<le>o |?L|"
+      using 22 ordIso_ordLeq_trans ordIso_symmetric by blast
+     }
+     ultimately have "|?L| <o |?L|" using ordLess_ordLeq_trans by blast
+     hence False using ordLess_irreflexive by blast
+    }
+    ultimately show "|K| =o ?r'"
+    unfolding ordLeq_iff_ordLess_or_ordIso by blast
+  qed
+qed
+
+lemma cardSuc_UNION:
+assumes r: "Card_order r" and "\<not>finite (Field r)"
+and As: "relChain (cardSuc r) As"
+and Bsub: "B \<le> (UN i : Field (cardSuc r). As i)"
+and cardB: "|B| <=o r"
+shows "EX i : Field (cardSuc r). B \<le> As i"
+proof-
+  let ?r' = "cardSuc r"
+  have "Card_order ?r' \<and> |B| <o ?r'"
+  using r cardB cardSuc_ordLeq_ordLess cardSuc_Card_order
+  card_of_Card_order by blast
+  moreover have "regular ?r'"
+  using assms by(simp add: infinite_cardSuc_regular)
+  ultimately show ?thesis
+  using As Bsub cardB regular_UNION by blast
+qed
+
+
+subsection {* Others *}
+
+lemma card_of_Func_Times:
+"|Func (A <*> B) C| =o |Func A (Func B C)|"
+unfolding card_of_ordIso[symmetric]
+using bij_betw_curr by blast
+
+lemma card_of_Pow_Func:
+"|Pow A| =o |Func A (UNIV::bool set)|"
+proof-
+  def F \<equiv> "\<lambda> A' a. if a \<in> A then (if a \<in> A' then True else False)
+                            else undefined"
+  have "bij_betw F (Pow A) (Func A (UNIV::bool set))"
+  unfolding bij_betw_def inj_on_def proof (intro ballI impI conjI)
+    fix A1 A2 assume "A1 \<in> Pow A" "A2 \<in> Pow A" "F A1 = F A2"
+    thus "A1 = A2" unfolding F_def Pow_def fun_eq_iff by (auto split: split_if_asm)
+  next
+    show "F ` Pow A = Func A UNIV"
+    proof safe
+      fix f assume f: "f \<in> Func A (UNIV::bool set)"
+      show "f \<in> F ` Pow A" unfolding image_def mem_Collect_eq proof(intro bexI)
+        let ?A1 = "{a \<in> A. f a = True}"
+        show "f = F ?A1" unfolding F_def apply(rule ext)
+        using f unfolding Func_def mem_Collect_eq by auto
+      qed auto
+    qed(unfold Func_def mem_Collect_eq F_def, auto)
+  qed
+  thus ?thesis unfolding card_of_ordIso[symmetric] by blast
+qed
+
+lemma card_of_Func_UNIV:
+"|Func (UNIV::'a set) (B::'b set)| =o |{f::'a \<Rightarrow> 'b. range f \<subseteq> B}|"
+apply(rule ordIso_symmetric) proof(intro card_of_ordIsoI)
+  let ?F = "\<lambda> f (a::'a). ((f a)::'b)"
+  show "bij_betw ?F {f. range f \<subseteq> B} (Func UNIV B)"
+  unfolding bij_betw_def inj_on_def proof safe
+    fix h :: "'a \<Rightarrow> 'b" assume h: "h \<in> Func UNIV B"
+    hence "\<forall> a. \<exists> b. h a = b" unfolding Func_def by auto
+    then obtain f where f: "\<forall> a. h a = f a" by metis
+    hence "range f \<subseteq> B" using h unfolding Func_def by auto
+    thus "h \<in> (\<lambda>f a. f a) ` {f. range f \<subseteq> B}" using f unfolding image_def by auto
+  qed(unfold Func_def fun_eq_iff, auto)
+qed
+
+end
--- a/src/HOL/Cardinals/Cardinal_Arithmetic_FP.thy	Mon Jan 20 16:14:19 2014 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,713 +0,0 @@
-(*  Title:      HOL/Cardinals/Cardinal_Arithmetic_FP.thy
-    Author:     Dmitriy Traytel, TU Muenchen
-    Copyright   2012
-
-Cardinal arithmetic (FP).
-*)
-
-header {* Cardinal Arithmetic (FP) *}
-
-theory Cardinal_Arithmetic_FP
-imports Cardinal_Order_Relation_FP
-begin
-
-(*library candidate*)
-lemma dir_image: "\<lbrakk>\<And>x y. (f x = f y) = (x = y); Card_order r\<rbrakk> \<Longrightarrow> r =o dir_image r f"
-by (rule dir_image_ordIso) (auto simp add: inj_on_def card_order_on_def)
-
-(*should supersede a weaker lemma from the library*)
-lemma dir_image_Field: "Field (dir_image r f) = f ` Field r"
-unfolding dir_image_def Field_def Range_def Domain_def by fast
-
-lemma card_order_dir_image:
-  assumes bij: "bij f" and co: "card_order r"
-  shows "card_order (dir_image r f)"
-proof -
-  from assms have "Field (dir_image r f) = UNIV"
-    using card_order_on_Card_order[of UNIV r] unfolding bij_def dir_image_Field by auto
-  moreover from bij have "\<And>x y. (f x = f y) = (x = y)" unfolding bij_def inj_on_def by auto
-  with co have "Card_order (dir_image r f)"
-    using card_order_on_Card_order[of UNIV r] Card_order_ordIso2[OF _ dir_image] by blast
-  ultimately show ?thesis by auto
-qed
-
-(*library candidate*)
-lemma ordIso_refl: "Card_order r \<Longrightarrow> r =o r"
-by (rule card_order_on_ordIso)
-
-(*library candidate*)
-lemma ordLeq_refl: "Card_order r \<Longrightarrow> r \<le>o r"
-by (rule ordIso_imp_ordLeq, rule card_order_on_ordIso)
-
-(*library candidate*)
-lemma card_of_ordIso_subst: "A = B \<Longrightarrow> |A| =o |B|"
-by (simp only: ordIso_refl card_of_Card_order)
-
-(*library candidate*)
-lemma Field_card_order: "card_order r \<Longrightarrow> Field r = UNIV"
-using card_order_on_Card_order[of UNIV r] by simp
-
-(*library candidate*)
-lemma card_of_Times_Plus_distrib:
-  "|A <*> (B <+> C)| =o |A <*> B <+> A <*> C|" (is "|?RHS| =o |?LHS|")
-proof -
-  let ?f = "\<lambda>(a, bc). case bc of Inl b \<Rightarrow> Inl (a, b) | Inr c \<Rightarrow> Inr (a, c)"
-  have "bij_betw ?f ?RHS ?LHS" unfolding bij_betw_def inj_on_def by force
-  thus ?thesis using card_of_ordIso by blast
-qed
-
-(*library candidate*)
-lemma Func_Times_Range:
-  "|Func A (B <*> C)| =o |Func A B <*> Func A C|" (is "|?LHS| =o |?RHS|")
-proof -
-  let ?F = "\<lambda>fg. (\<lambda>x. if x \<in> A then fst (fg x) else undefined,
-                  \<lambda>x. if x \<in> A then snd (fg x) else undefined)"
-  let ?G = "\<lambda>(f, g) x. if x \<in> A then (f x, g x) else undefined"
-  have "bij_betw ?F ?LHS ?RHS" unfolding bij_betw_def inj_on_def
-  apply safe
-     apply (simp add: Func_def fun_eq_iff)
-     apply (metis (no_types) pair_collapse)
-    apply (auto simp: Func_def fun_eq_iff)[2]
-  proof -
-    fix f g assume "f \<in> Func A B" "g \<in> Func A C"
-    thus "(f, g) \<in> ?F ` Func A (B \<times> C)"
-      by (intro image_eqI[of _ _ "?G (f, g)"]) (auto simp: Func_def)
-  qed
-  thus ?thesis using card_of_ordIso by blast
-qed
-
-
-subsection {* Zero *}
-
-definition czero where
-  "czero = card_of {}"
-
-lemma czero_ordIso:
-  "czero =o czero"
-using card_of_empty_ordIso by (simp add: czero_def)
-
-lemma card_of_ordIso_czero_iff_empty:
-  "|A| =o (czero :: 'b rel) \<longleftrightarrow> A = ({} :: 'a set)"
-unfolding czero_def by (rule iffI[OF card_of_empty2]) (auto simp: card_of_refl card_of_empty_ordIso)
-
-(* A "not czero" Cardinal predicate *)
-abbreviation Cnotzero where
-  "Cnotzero (r :: 'a rel) \<equiv> \<not>(r =o (czero :: 'a rel)) \<and> Card_order r"
-
-(*helper*)
-lemma Cnotzero_imp_not_empty: "Cnotzero r \<Longrightarrow> Field r \<noteq> {}"
-by (metis Card_order_iff_ordIso_card_of czero_def)
-
-lemma czeroI:
-  "\<lbrakk>Card_order r; Field r = {}\<rbrakk> \<Longrightarrow> r =o czero"
-using Cnotzero_imp_not_empty ordIso_transitive[OF _ czero_ordIso] by blast
-
-lemma czeroE:
-  "r =o czero \<Longrightarrow> Field r = {}"
-unfolding czero_def
-by (drule card_of_cong) (simp only: Field_card_of card_of_empty2)
-
-lemma Cnotzero_mono:
-  "\<lbrakk>Cnotzero r; Card_order q; r \<le>o q\<rbrakk> \<Longrightarrow> Cnotzero q"
-apply (rule ccontr)
-apply auto
-apply (drule czeroE)
-apply (erule notE)
-apply (erule czeroI)
-apply (drule card_of_mono2)
-apply (simp only: card_of_empty3)
-done
-
-subsection {* (In)finite cardinals *}
-
-definition cinfinite where
-  "cinfinite r = (\<not> finite (Field r))"
-
-abbreviation Cinfinite where
-  "Cinfinite r \<equiv> cinfinite r \<and> Card_order r"
-
-definition cfinite where
-  "cfinite r = finite (Field r)"
-
-abbreviation Cfinite where
-  "Cfinite r \<equiv> cfinite r \<and> Card_order r"
-
-lemma Cfinite_ordLess_Cinfinite: "\<lbrakk>Cfinite r; Cinfinite s\<rbrakk> \<Longrightarrow> r <o s"
-  unfolding cfinite_def cinfinite_def
-  by (metis card_order_on_well_order_on finite_ordLess_infinite)
-
-lemmas natLeq_card_order = natLeq_Card_order[unfolded Field_natLeq]
-
-lemma natLeq_cinfinite: "cinfinite natLeq"
-unfolding cinfinite_def Field_natLeq by (metis infinite_UNIV_nat)
-
-lemma natLeq_ordLeq_cinfinite:
-  assumes inf: "Cinfinite r"
-  shows "natLeq \<le>o r"
-proof -
-  from inf have "natLeq \<le>o |Field r|" by (metis cinfinite_def infinite_iff_natLeq_ordLeq)
-  also from inf have "|Field r| =o r" by (simp add: card_of_unique ordIso_symmetric)
-  finally show ?thesis .
-qed
-
-lemma cinfinite_not_czero: "cinfinite r \<Longrightarrow> \<not> (r =o (czero :: 'a rel))"
-unfolding cinfinite_def by (metis czeroE finite.emptyI)
-
-lemma Cinfinite_Cnotzero: "Cinfinite r \<Longrightarrow> Cnotzero r"
-by (metis cinfinite_not_czero)
-
-lemma Cinfinite_cong: "\<lbrakk>r1 =o r2; Cinfinite r1\<rbrakk> \<Longrightarrow> Cinfinite r2"
-by (metis Card_order_ordIso2 card_of_mono2 card_of_ordLeq_infinite cinfinite_def ordIso_iff_ordLeq)
-
-lemma cinfinite_mono: "\<lbrakk>r1 \<le>o r2; cinfinite r1\<rbrakk> \<Longrightarrow> cinfinite r2"
-by (metis card_of_mono2 card_of_ordLeq_infinite cinfinite_def)
-
-
-subsection {* Binary sum *}
-
-definition csum (infixr "+c" 65) where
-  "r1 +c r2 \<equiv> |Field r1 <+> Field r2|"
-
-lemma Field_csum: "Field (r +c s) = Inl ` Field r \<union> Inr ` Field s"
-  unfolding csum_def Field_card_of by auto
-
-lemma Card_order_csum:
-  "Card_order (r1 +c r2)"
-unfolding csum_def by (simp add: card_of_Card_order)
-
-lemma csum_Cnotzero1:
-  "Cnotzero r1 \<Longrightarrow> Cnotzero (r1 +c r2)"
-unfolding csum_def
-by (metis Cnotzero_imp_not_empty Plus_eq_empty_conv card_of_Card_order card_of_ordIso_czero_iff_empty)
-
-lemma card_order_csum:
-  assumes "card_order r1" "card_order r2"
-  shows "card_order (r1 +c r2)"
-proof -
-  have "Field r1 = UNIV" "Field r2 = UNIV" using assms card_order_on_Card_order by auto
-  thus ?thesis unfolding csum_def by (auto simp: card_of_card_order_on)
-qed
-
-lemma cinfinite_csum:
-  "cinfinite r1 \<or> cinfinite r2 \<Longrightarrow> cinfinite (r1 +c r2)"
-unfolding cinfinite_def csum_def by (auto simp: Field_card_of)
-
-lemma Cinfinite_csum1:
-  "Cinfinite r1 \<Longrightarrow> Cinfinite (r1 +c r2)"
-unfolding cinfinite_def csum_def by (metis Field_card_of card_of_Card_order finite_Plus_iff)
-
-lemma Cinfinite_csum:
-  "Cinfinite r1 \<or> Cinfinite r2 \<Longrightarrow> Cinfinite (r1 +c r2)"
-unfolding cinfinite_def csum_def by (metis Field_card_of card_of_Card_order finite_Plus_iff)
-
-lemma Cinfinite_csum_strong:
-  "\<lbrakk>Cinfinite r1; Cinfinite r2\<rbrakk> \<Longrightarrow> Cinfinite (r1 +c r2)"
-by (metis Cinfinite_csum)
-
-lemma csum_cong: "\<lbrakk>p1 =o r1; p2 =o r2\<rbrakk> \<Longrightarrow> p1 +c p2 =o r1 +c r2"
-by (simp only: csum_def ordIso_Plus_cong)
-
-lemma csum_cong1: "p1 =o r1 \<Longrightarrow> p1 +c q =o r1 +c q"
-by (simp only: csum_def ordIso_Plus_cong1)
-
-lemma csum_cong2: "p2 =o r2 \<Longrightarrow> q +c p2 =o q +c r2"
-by (simp only: csum_def ordIso_Plus_cong2)
-
-lemma csum_mono: "\<lbrakk>p1 \<le>o r1; p2 \<le>o r2\<rbrakk> \<Longrightarrow> p1 +c p2 \<le>o r1 +c r2"
-by (simp only: csum_def ordLeq_Plus_mono)
-
-lemma csum_mono1: "p1 \<le>o r1 \<Longrightarrow> p1 +c q \<le>o r1 +c q"
-by (simp only: csum_def ordLeq_Plus_mono1)
-
-lemma csum_mono2: "p2 \<le>o r2 \<Longrightarrow> q +c p2 \<le>o q +c r2"
-by (simp only: csum_def ordLeq_Plus_mono2)
-
-lemma ordLeq_csum1: "Card_order p1 \<Longrightarrow> p1 \<le>o p1 +c p2"
-by (simp only: csum_def Card_order_Plus1)
-
-lemma ordLeq_csum2: "Card_order p2 \<Longrightarrow> p2 \<le>o p1 +c p2"
-by (simp only: csum_def Card_order_Plus2)
-
-lemma csum_com: "p1 +c p2 =o p2 +c p1"
-by (simp only: csum_def card_of_Plus_commute)
-
-lemma csum_assoc: "(p1 +c p2) +c p3 =o p1 +c p2 +c p3"
-by (simp only: csum_def Field_card_of card_of_Plus_assoc)
-
-lemma Cfinite_csum: "\<lbrakk>Cfinite r; Cfinite s\<rbrakk> \<Longrightarrow> Cfinite (r +c s)"
-  unfolding cfinite_def csum_def Field_card_of using card_of_card_order_on by simp
-
-lemma csum_csum: "(r1 +c r2) +c (r3 +c r4) =o (r1 +c r3) +c (r2 +c r4)"
-proof -
-  have "(r1 +c r2) +c (r3 +c r4) =o r1 +c r2 +c (r3 +c r4)"
-    by (metis csum_assoc)
-  also have "r1 +c r2 +c (r3 +c r4) =o r1 +c (r2 +c r3) +c r4"
-    by (metis csum_assoc csum_cong2 ordIso_symmetric)
-  also have "r1 +c (r2 +c r3) +c r4 =o r1 +c (r3 +c r2) +c r4"
-    by (metis csum_com csum_cong1 csum_cong2)
-  also have "r1 +c (r3 +c r2) +c r4 =o r1 +c r3 +c r2 +c r4"
-    by (metis csum_assoc csum_cong2 ordIso_symmetric)
-  also have "r1 +c r3 +c r2 +c r4 =o (r1 +c r3) +c (r2 +c r4)"
-    by (metis csum_assoc ordIso_symmetric)
-  finally show ?thesis .
-qed
-
-lemma Plus_csum: "|A <+> B| =o |A| +c |B|"
-by (simp only: csum_def Field_card_of card_of_refl)
-
-lemma Un_csum: "|A \<union> B| \<le>o |A| +c |B|"
-using ordLeq_ordIso_trans[OF card_of_Un_Plus_ordLeq Plus_csum] by blast
-
-
-subsection {* One *}
-
-definition cone where
-  "cone = card_of {()}"
-
-lemma Card_order_cone: "Card_order cone"
-unfolding cone_def by (rule card_of_Card_order)
-
-lemma Cfinite_cone: "Cfinite cone"
-  unfolding cfinite_def by (simp add: Card_order_cone)
-
-lemma cone_not_czero: "\<not> (cone =o czero)"
-unfolding czero_def cone_def by (metis empty_not_insert card_of_empty3[of "{()}"] ordIso_iff_ordLeq)
-
-lemma cone_ordLeq_Cnotzero: "Cnotzero r \<Longrightarrow> cone \<le>o r"
-unfolding cone_def by (metis Card_order_singl_ordLeq czeroI)
-
-
-subsection{* Two *}
-
-definition ctwo where
-  "ctwo = |UNIV :: bool set|"
-
-lemma Card_order_ctwo: "Card_order ctwo"
-unfolding ctwo_def by (rule card_of_Card_order)
-
-lemma ctwo_not_czero: "\<not> (ctwo =o czero)"
-using card_of_empty3[of "UNIV :: bool set"] ordIso_iff_ordLeq
-unfolding czero_def ctwo_def by (metis UNIV_not_empty)
-
-lemma ctwo_Cnotzero: "Cnotzero ctwo"
-by (simp add: ctwo_not_czero Card_order_ctwo)
-
-
-subsection {* Family sum *}
-
-definition Csum where
-  "Csum r rs \<equiv> |SIGMA i : Field r. Field (rs i)|"
-
-(* Similar setup to the one for SIGMA from theory Big_Operators: *)
-syntax "_Csum" ::
-  "pttrn => ('a * 'a) set => 'b * 'b set => (('a * 'b) * ('a * 'b)) set"
-  ("(3CSUM _:_. _)" [0, 51, 10] 10)
-
-translations
-  "CSUM i:r. rs" == "CONST Csum r (%i. rs)"
-
-lemma SIGMA_CSUM: "|SIGMA i : I. As i| = (CSUM i : |I|. |As i| )"
-by (auto simp: Csum_def Field_card_of)
-
-(* NB: Always, under the cardinal operator,
-operations on sets are reduced automatically to operations on cardinals.
-This should make cardinal reasoning more direct and natural.  *)
-
-
-subsection {* Product *}
-
-definition cprod (infixr "*c" 80) where
-  "r1 *c r2 = |Field r1 <*> Field r2|"
-
-lemma card_order_cprod:
-  assumes "card_order r1" "card_order r2"
-  shows "card_order (r1 *c r2)"
-proof -
-  have "Field r1 = UNIV" "Field r2 = UNIV" using assms card_order_on_Card_order by auto
-  thus ?thesis by (auto simp: cprod_def card_of_card_order_on)
-qed
-
-lemma Card_order_cprod: "Card_order (r1 *c r2)"
-by (simp only: cprod_def Field_card_of card_of_card_order_on)
-
-lemma cprod_mono1: "p1 \<le>o r1 \<Longrightarrow> p1 *c q \<le>o r1 *c q"
-by (simp only: cprod_def ordLeq_Times_mono1)
-
-lemma cprod_mono2: "p2 \<le>o r2 \<Longrightarrow> q *c p2 \<le>o q *c r2"
-by (simp only: cprod_def ordLeq_Times_mono2)
-
-lemma ordLeq_cprod2: "\<lbrakk>Cnotzero p1; Card_order p2\<rbrakk> \<Longrightarrow> p2 \<le>o p1 *c p2"
-unfolding cprod_def by (metis Card_order_Times2 czeroI)
-
-lemma cinfinite_cprod: "\<lbrakk>cinfinite r1; cinfinite r2\<rbrakk> \<Longrightarrow> cinfinite (r1 *c r2)"
-by (simp add: cinfinite_def cprod_def Field_card_of infinite_cartesian_product)
-
-lemma cinfinite_cprod2: "\<lbrakk>Cnotzero r1; Cinfinite r2\<rbrakk> \<Longrightarrow> cinfinite (r1 *c r2)"
-by (metis cinfinite_mono ordLeq_cprod2)
-
-lemma Cinfinite_cprod2: "\<lbrakk>Cnotzero r1; Cinfinite r2\<rbrakk> \<Longrightarrow> Cinfinite (r1 *c r2)"
-by (blast intro: cinfinite_cprod2 Card_order_cprod)
-
-lemma cprod_com: "p1 *c p2 =o p2 *c p1"
-by (simp only: cprod_def card_of_Times_commute)
-
-lemma card_of_Csum_Times:
-  "\<forall>i \<in> I. |A i| \<le>o |B| \<Longrightarrow> (CSUM i : |I|. |A i| ) \<le>o |I| *c |B|"
-by (simp only: Csum_def cprod_def Field_card_of card_of_Sigma_Times)
-
-lemma card_of_Csum_Times':
-  assumes "Card_order r" "\<forall>i \<in> I. |A i| \<le>o r"
-  shows "(CSUM i : |I|. |A i| ) \<le>o |I| *c r"
-proof -
-  from assms(1) have *: "r =o |Field r|" by (simp add: card_of_unique)
-  with assms(2) have "\<forall>i \<in> I. |A i| \<le>o |Field r|" by (blast intro: ordLeq_ordIso_trans)
-  hence "(CSUM i : |I|. |A i| ) \<le>o |I| *c |Field r|" by (simp only: card_of_Csum_Times)
-  also from * have "|I| *c |Field r| \<le>o |I| *c r"
-    by (simp only: Field_card_of card_of_refl cprod_def ordIso_imp_ordLeq)
-  finally show ?thesis .
-qed
-
-lemma cprod_csum_distrib1: "r1 *c r2 +c r1 *c r3 =o r1 *c (r2 +c r3)"
-unfolding csum_def cprod_def by (simp add: Field_card_of card_of_Times_Plus_distrib ordIso_symmetric)
-
-lemma csum_absorb2': "\<lbrakk>Card_order r2; r1 \<le>o r2; cinfinite r1 \<or> cinfinite r2\<rbrakk> \<Longrightarrow> r1 +c r2 =o r2"
-unfolding csum_def by (metis Card_order_Plus_infinite cinfinite_def cinfinite_mono)
-
-lemma csum_absorb1':
-  assumes card: "Card_order r2"
-  and r12: "r1 \<le>o r2" and cr12: "cinfinite r1 \<or> cinfinite r2"
-  shows "r2 +c r1 =o r2"
-by (rule ordIso_transitive, rule csum_com, rule csum_absorb2', (simp only: assms)+)
-
-lemma csum_absorb1: "\<lbrakk>Cinfinite r2; r1 \<le>o r2\<rbrakk> \<Longrightarrow> r2 +c r1 =o r2"
-by (rule csum_absorb1') auto
-
-
-subsection {* Exponentiation *}
-
-definition cexp (infixr "^c" 90) where
-  "r1 ^c r2 \<equiv> |Func (Field r2) (Field r1)|"
-
-lemma Card_order_cexp: "Card_order (r1 ^c r2)"
-unfolding cexp_def by (rule card_of_Card_order)
-
-lemma cexp_mono':
-  assumes 1: "p1 \<le>o r1" and 2: "p2 \<le>o r2"
-  and n: "Field p2 = {} \<Longrightarrow> Field r2 = {}"
-  shows "p1 ^c p2 \<le>o r1 ^c r2"
-proof(cases "Field p1 = {}")
-  case True
-  hence "|Field |Func (Field p2) (Field p1)|| \<le>o cone"
-    unfolding cone_def Field_card_of
-    by (cases "Field p2 = {}", auto intro: card_of_ordLeqI2 simp: Func_empty)
-       (metis Func_is_emp card_of_empty ex_in_conv)
-  hence "|Func (Field p2) (Field p1)| \<le>o cone" by (simp add: Field_card_of cexp_def)
-  hence "p1 ^c p2 \<le>o cone" unfolding cexp_def .
-  thus ?thesis
-  proof (cases "Field p2 = {}")
-    case True
-    with n have "Field r2 = {}" .
-    hence "cone \<le>o r1 ^c r2" unfolding cone_def cexp_def Func_def by (auto intro: card_of_ordLeqI)
-    thus ?thesis using `p1 ^c p2 \<le>o cone` ordLeq_transitive by auto
-  next
-    case False with True have "|Field (p1 ^c p2)| =o czero"
-      unfolding card_of_ordIso_czero_iff_empty cexp_def Field_card_of Func_def by auto
-    thus ?thesis unfolding cexp_def card_of_ordIso_czero_iff_empty Field_card_of
-      by (simp add: card_of_empty)
-  qed
-next
-  case False
-  have 1: "|Field p1| \<le>o |Field r1|" and 2: "|Field p2| \<le>o |Field r2|"
-    using 1 2 by (auto simp: card_of_mono2)
-  obtain f1 where f1: "f1 ` Field r1 = Field p1"
-    using 1 unfolding card_of_ordLeq2[OF False, symmetric] by auto
-  obtain f2 where f2: "inj_on f2 (Field p2)" "f2 ` Field p2 \<subseteq> Field r2"
-    using 2 unfolding card_of_ordLeq[symmetric] by blast
-  have 0: "Func_map (Field p2) f1 f2 ` (Field (r1 ^c r2)) = Field (p1 ^c p2)"
-    unfolding cexp_def Field_card_of using Func_map_surj[OF f1 f2 n, symmetric] .
-  have 00: "Field (p1 ^c p2) \<noteq> {}" unfolding cexp_def Field_card_of Func_is_emp
-    using False by simp
-  show ?thesis
-    using 0 card_of_ordLeq2[OF 00] unfolding cexp_def Field_card_of by blast
-qed
-
-lemma cexp_mono:
-  assumes 1: "p1 \<le>o r1" and 2: "p2 \<le>o r2"
-  and n: "p2 =o czero \<Longrightarrow> r2 =o czero" and card: "Card_order p2"
-  shows "p1 ^c p2 \<le>o r1 ^c r2"
-  by (metis (full_types) "1" "2" card cexp_mono' czeroE czeroI n)
-
-lemma cexp_mono1:
-  assumes 1: "p1 \<le>o r1" and q: "Card_order q"
-  shows "p1 ^c q \<le>o r1 ^c q"
-using ordLeq_refl[OF q] by (rule cexp_mono[OF 1]) (auto simp: q)
-
-lemma cexp_mono2':
-  assumes 2: "p2 \<le>o r2" and q: "Card_order q"
-  and n: "Field p2 = {} \<Longrightarrow> Field r2 = {}"
-  shows "q ^c p2 \<le>o q ^c r2"
-using ordLeq_refl[OF q] by (rule cexp_mono'[OF _ 2 n]) auto
-
-lemma cexp_mono2:
-  assumes 2: "p2 \<le>o r2" and q: "Card_order q"
-  and n: "p2 =o czero \<Longrightarrow> r2 =o czero" and card: "Card_order p2"
-  shows "q ^c p2 \<le>o q ^c r2"
-using ordLeq_refl[OF q] by (rule cexp_mono[OF _ 2 n card]) auto
-
-lemma cexp_mono2_Cnotzero:
-  assumes "p2 \<le>o r2" "Card_order q" "Cnotzero p2"
-  shows "q ^c p2 \<le>o q ^c r2"
-by (metis assms cexp_mono2' czeroI)
-
-lemma cexp_cong:
-  assumes 1: "p1 =o r1" and 2: "p2 =o r2"
-  and Cr: "Card_order r2"
-  and Cp: "Card_order p2"
-  shows "p1 ^c p2 =o r1 ^c r2"
-proof -
-  obtain f where "bij_betw f (Field p2) (Field r2)"
-    using 2 card_of_ordIso[of "Field p2" "Field r2"] card_of_cong by auto
-  hence 0: "Field p2 = {} \<longleftrightarrow> Field r2 = {}" unfolding bij_betw_def by auto
-  have r: "p2 =o czero \<Longrightarrow> r2 =o czero"
-    and p: "r2 =o czero \<Longrightarrow> p2 =o czero"
-     using 0 Cr Cp czeroE czeroI by auto
-  show ?thesis using 0 1 2 unfolding ordIso_iff_ordLeq
-    using r p cexp_mono[OF _ _ _ Cp] cexp_mono[OF _ _ _ Cr] by metis
-qed
-
-lemma cexp_cong1:
-  assumes 1: "p1 =o r1" and q: "Card_order q"
-  shows "p1 ^c q =o r1 ^c q"
-by (rule cexp_cong[OF 1 _ q q]) (rule ordIso_refl[OF q])
-
-lemma cexp_cong2:
-  assumes 2: "p2 =o r2" and q: "Card_order q" and p: "Card_order p2"
-  shows "q ^c p2 =o q ^c r2"
-by (rule cexp_cong[OF _ 2]) (auto simp only: ordIso_refl Card_order_ordIso2[OF p 2] q p)
-
-lemma cexp_cone:
-  assumes "Card_order r"
-  shows "r ^c cone =o r"
-proof -
-  have "r ^c cone =o |Field r|"
-    unfolding cexp_def cone_def Field_card_of Func_empty
-      card_of_ordIso[symmetric] bij_betw_def Func_def inj_on_def image_def
-    by (rule exI[of _ "\<lambda>f. f ()"]) auto
-  also have "|Field r| =o r" by (rule card_of_Field_ordIso[OF assms])
-  finally show ?thesis .
-qed
-
-lemma cexp_cprod:
-  assumes r1: "Card_order r1"
-  shows "(r1 ^c r2) ^c r3 =o r1 ^c (r2 *c r3)" (is "?L =o ?R")
-proof -
-  have "?L =o r1 ^c (r3 *c r2)"
-    unfolding cprod_def cexp_def Field_card_of
-    using card_of_Func_Times by(rule ordIso_symmetric)
-  also have "r1 ^c (r3 *c r2) =o ?R"
-    apply(rule cexp_cong2) using cprod_com r1 by (auto simp: Card_order_cprod)
-  finally show ?thesis .
-qed
-
-lemma cprod_infinite1': "\<lbrakk>Cinfinite r; Cnotzero p; p \<le>o r\<rbrakk> \<Longrightarrow> r *c p =o r"
-unfolding cinfinite_def cprod_def
-by (rule Card_order_Times_infinite[THEN conjunct1]) (blast intro: czeroI)+
-
-lemma cexp_cprod_ordLeq:
-  assumes r1: "Card_order r1" and r2: "Cinfinite r2"
-  and r3: "Cnotzero r3" "r3 \<le>o r2"
-  shows "(r1 ^c r2) ^c r3 =o r1 ^c r2" (is "?L =o ?R")
-proof-
-  have "?L =o r1 ^c (r2 *c r3)" using cexp_cprod[OF r1] .
-  also have "r1 ^c (r2 *c r3) =o ?R"
-  apply(rule cexp_cong2)
-  apply(rule cprod_infinite1'[OF r2 r3]) using r1 r2 by (fastforce simp: Card_order_cprod)+
-  finally show ?thesis .
-qed
-
-lemma Cnotzero_UNIV: "Cnotzero |UNIV|"
-by (auto simp: card_of_Card_order card_of_ordIso_czero_iff_empty)
-
-lemma ordLess_ctwo_cexp:
-  assumes "Card_order r"
-  shows "r <o ctwo ^c r"
-proof -
-  have "r <o |Pow (Field r)|" using assms by (rule Card_order_Pow)
-  also have "|Pow (Field r)| =o ctwo ^c r"
-    unfolding ctwo_def cexp_def Field_card_of by (rule card_of_Pow_Func)
-  finally show ?thesis .
-qed
-
-lemma ordLeq_cexp1:
-  assumes "Cnotzero r" "Card_order q"
-  shows "q \<le>o q ^c r"
-proof (cases "q =o (czero :: 'a rel)")
-  case True thus ?thesis by (simp only: card_of_empty cexp_def czero_def ordIso_ordLeq_trans)
-next
-  case False
-  thus ?thesis
-    apply -
-    apply (rule ordIso_ordLeq_trans)
-    apply (rule ordIso_symmetric)
-    apply (rule cexp_cone)
-    apply (rule assms(2))
-    apply (rule cexp_mono2)
-    apply (rule cone_ordLeq_Cnotzero)
-    apply (rule assms(1))
-    apply (rule assms(2))
-    apply (rule notE)
-    apply (rule cone_not_czero)
-    apply assumption
-    apply (rule Card_order_cone)
-  done
-qed
-
-lemma ordLeq_cexp2:
-  assumes "ctwo \<le>o q" "Card_order r"
-  shows "r \<le>o q ^c r"
-proof (cases "r =o (czero :: 'a rel)")
-  case True thus ?thesis by (simp only: card_of_empty cexp_def czero_def ordIso_ordLeq_trans)
-next
-  case False thus ?thesis
-    apply -
-    apply (rule ordLess_imp_ordLeq)
-    apply (rule ordLess_ordLeq_trans)
-    apply (rule ordLess_ctwo_cexp)
-    apply (rule assms(2))
-    apply (rule cexp_mono1)
-    apply (rule assms(1))
-    apply (rule assms(2))
-  done
-qed
-
-lemma cinfinite_cexp: "\<lbrakk>ctwo \<le>o q; Cinfinite r\<rbrakk> \<Longrightarrow> cinfinite (q ^c r)"
-by (metis assms cinfinite_mono ordLeq_cexp2)
-
-lemma Cinfinite_cexp:
-  "\<lbrakk>ctwo \<le>o q; Cinfinite r\<rbrakk> \<Longrightarrow> Cinfinite (q ^c r)"
-by (simp add: cinfinite_cexp Card_order_cexp)
-
-lemma ctwo_ordLess_natLeq: "ctwo <o natLeq"
-unfolding ctwo_def using finite_UNIV natLeq_cinfinite natLeq_Card_order
-by (intro Cfinite_ordLess_Cinfinite) (auto simp: cfinite_def card_of_Card_order)
-
-lemma ctwo_ordLess_Cinfinite: "Cinfinite r \<Longrightarrow> ctwo <o r"
-by (metis ctwo_ordLess_natLeq natLeq_ordLeq_cinfinite ordLess_ordLeq_trans)
-
-lemma ctwo_ordLeq_Cinfinite:
-  assumes "Cinfinite r"
-  shows "ctwo \<le>o r"
-by (rule ordLess_imp_ordLeq[OF ctwo_ordLess_Cinfinite[OF assms]])
-
-lemma Un_Cinfinite_bound: "\<lbrakk>|A| \<le>o r; |B| \<le>o r; Cinfinite r\<rbrakk> \<Longrightarrow> |A \<union> B| \<le>o r"
-by (auto simp add: cinfinite_def card_of_Un_ordLeq_infinite_Field)
-
-lemma UNION_Cinfinite_bound: "\<lbrakk>|I| \<le>o r; \<forall>i \<in> I. |A i| \<le>o r; Cinfinite r\<rbrakk> \<Longrightarrow> |\<Union>i \<in> I. A i| \<le>o r"
-by (auto simp add: card_of_UNION_ordLeq_infinite_Field cinfinite_def)
-
-lemma csum_cinfinite_bound:
-  assumes "p \<le>o r" "q \<le>o r" "Card_order p" "Card_order q" "Cinfinite r"
-  shows "p +c q \<le>o r"
-proof -
-  from assms(1-4) have "|Field p| \<le>o r" "|Field q| \<le>o r"
-    unfolding card_order_on_def using card_of_least ordLeq_transitive by blast+
-  with assms show ?thesis unfolding cinfinite_def csum_def
-    by (blast intro: card_of_Plus_ordLeq_infinite_Field)
-qed
-
-lemma cprod_cinfinite_bound:
-  assumes "p \<le>o r" "q \<le>o r" "Card_order p" "Card_order q" "Cinfinite r"
-  shows "p *c q \<le>o r"
-proof -
-  from assms(1-4) have "|Field p| \<le>o r" "|Field q| \<le>o r"
-    unfolding card_order_on_def using card_of_least ordLeq_transitive by blast+
-  with assms show ?thesis unfolding cinfinite_def cprod_def
-    by (blast intro: card_of_Times_ordLeq_infinite_Field)
-qed
-
-lemma cprod_csum_cexp:
-  "r1 *c r2 \<le>o (r1 +c r2) ^c ctwo"
-unfolding cprod_def csum_def cexp_def ctwo_def Field_card_of
-proof -
-  let ?f = "\<lambda>(a, b). %x. if x then Inl a else Inr b"
-  have "inj_on ?f (Field r1 \<times> Field r2)" (is "inj_on _ ?LHS")
-    by (auto simp: inj_on_def fun_eq_iff split: bool.split)
-  moreover
-  have "?f ` ?LHS \<subseteq> Func (UNIV :: bool set) (Field r1 <+> Field r2)" (is "_ \<subseteq> ?RHS")
-    by (auto simp: Func_def)
-  ultimately show "|?LHS| \<le>o |?RHS|" using card_of_ordLeq by blast
-qed
-
-lemma Cfinite_cprod_Cinfinite: "\<lbrakk>Cfinite r; Cinfinite s\<rbrakk> \<Longrightarrow> r *c s \<le>o s"
-by (intro cprod_cinfinite_bound)
-  (auto intro: ordLeq_refl ordLess_imp_ordLeq[OF Cfinite_ordLess_Cinfinite])
-
-lemma cprod_cexp: "(r *c s) ^c t =o r ^c t *c s ^c t"
-  unfolding cprod_def cexp_def Field_card_of by (rule Func_Times_Range)
-
-lemma cprod_cexp_csum_cexp_Cinfinite:
-  assumes t: "Cinfinite t"
-  shows "(r *c s) ^c t \<le>o (r +c s) ^c t"
-proof -
-  have "(r *c s) ^c t \<le>o ((r +c s) ^c ctwo) ^c t"
-    by (rule cexp_mono1[OF cprod_csum_cexp conjunct2[OF t]])
-  also have "((r +c s) ^c ctwo) ^c t =o (r +c s) ^c (ctwo *c t)"
-    by (rule cexp_cprod[OF Card_order_csum])
-  also have "(r +c s) ^c (ctwo *c t) =o (r +c s) ^c (t *c ctwo)"
-    by (rule cexp_cong2[OF cprod_com Card_order_csum Card_order_cprod])
-  also have "(r +c s) ^c (t *c ctwo) =o ((r +c s) ^c t) ^c ctwo"
-    by (rule ordIso_symmetric[OF cexp_cprod[OF Card_order_csum]])
-  also have "((r +c s) ^c t) ^c ctwo =o (r +c s) ^c t"
-    by (rule cexp_cprod_ordLeq[OF Card_order_csum t ctwo_Cnotzero ctwo_ordLeq_Cinfinite[OF t]])
-  finally show ?thesis .
-qed
-
-lemma Cfinite_cexp_Cinfinite:
-  assumes s: "Cfinite s" and t: "Cinfinite t"
-  shows "s ^c t \<le>o ctwo ^c t"
-proof (cases "s \<le>o ctwo")
-  case True thus ?thesis using t by (blast intro: cexp_mono1)
-next
-  case False
-  hence "ctwo \<le>o s" by (metis card_order_on_well_order_on ctwo_Cnotzero ordLeq_total s)
-  hence "Cnotzero s" by (metis Cnotzero_mono ctwo_Cnotzero s)
-  hence st: "Cnotzero (s *c t)" by (metis Cinfinite_cprod2 cinfinite_not_czero t)
-  have "s ^c t \<le>o (ctwo ^c s) ^c t"
-    using assms by (blast intro: cexp_mono1 ordLess_imp_ordLeq[OF ordLess_ctwo_cexp])
-  also have "(ctwo ^c s) ^c t =o ctwo ^c (s *c t)"
-    by (blast intro: Card_order_ctwo cexp_cprod)
-  also have "ctwo ^c (s *c t) \<le>o ctwo ^c t"
-    using assms st by (intro cexp_mono2_Cnotzero Cfinite_cprod_Cinfinite Card_order_ctwo)
-  finally show ?thesis .
-qed
-
-lemma csum_Cfinite_cexp_Cinfinite:
-  assumes r: "Card_order r" and s: "Cfinite s" and t: "Cinfinite t"
-  shows "(r +c s) ^c t \<le>o (r +c ctwo) ^c t"
-proof (cases "Cinfinite r")
-  case True
-  hence "r +c s =o r" by (intro csum_absorb1 ordLess_imp_ordLeq[OF Cfinite_ordLess_Cinfinite] s)
-  hence "(r +c s) ^c t =o r ^c t" using t by (blast intro: cexp_cong1)
-  also have "r ^c t \<le>o (r +c ctwo) ^c t" using t by (blast intro: cexp_mono1 ordLeq_csum1 r)
-  finally show ?thesis .
-next
-  case False
-  with r have "Cfinite r" unfolding cinfinite_def cfinite_def by auto
-  hence "Cfinite (r +c s)" by (intro Cfinite_csum s)
-  hence "(r +c s) ^c t \<le>o ctwo ^c t" by (intro Cfinite_cexp_Cinfinite t)
-  also have "ctwo ^c t \<le>o (r +c ctwo) ^c t" using t
-    by (blast intro: cexp_mono1 ordLeq_csum2 Card_order_ctwo)
-  finally show ?thesis .
-qed
-
-(* cardSuc *)
-
-lemma Cinfinite_cardSuc: "Cinfinite r \<Longrightarrow> Cinfinite (cardSuc r)"
-by (simp add: cinfinite_def cardSuc_Card_order cardSuc_finite)
-
-lemma cardSuc_UNION_Cinfinite:
-  assumes "Cinfinite r" "relChain (cardSuc r) As" "B \<le> (UN i : Field (cardSuc r). As i)" "|B| <=o r"
-  shows "EX i : Field (cardSuc r). B \<le> As i"
-using cardSuc_UNION assms unfolding cinfinite_def by blast
-
-end
--- a/src/HOL/Cardinals/Cardinal_Order_Relation_FP.thy	Mon Jan 20 16:14:19 2014 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1828 +0,0 @@
-(*  Title:      HOL/Cardinals/Cardinal_Order_Relation_FP.thy
-    Author:     Andrei Popescu, TU Muenchen
-    Copyright   2012
-
-Cardinal-order relations (FP).
-*)
-
-header {* Cardinal-Order Relations (FP) *}
-
-theory Cardinal_Order_Relation_FP
-imports Constructions_on_Wellorders_FP
-begin
-
-
-text{* In this section, we define cardinal-order relations to be minim well-orders
-on their field.  Then we define the cardinal of a set to be {\em some} cardinal-order
-relation on that set, which will be unique up to order isomorphism.  Then we study
-the connection between cardinals and:
-\begin{itemize}
-\item standard set-theoretic constructions: products,
-sums, unions, lists, powersets, set-of finite sets operator;
-\item finiteness and infiniteness (in particular, with the numeric cardinal operator
-for finite sets, @{text "card"}, from the theory @{text "Finite_Sets.thy"}).
-\end{itemize}
-%
-On the way, we define the canonical $\omega$ cardinal and finite cardinals.  We also
-define (again, up to order isomorphism) the successor of a cardinal, and show that
-any cardinal admits a successor.
-
-Main results of this section are the existence of cardinal relations and the
-facts that, in the presence of infiniteness,
-most of the standard set-theoretic constructions (except for the powerset)
-{\em do not increase cardinality}.  In particular, e.g., the set of words/lists over
-any infinite set has the same cardinality (hence, is in bijection) with that set.
-*}
-
-
-subsection {* Cardinal orders *}
-
-
-text{* A cardinal order in our setting shall be a well-order {\em minim} w.r.t. the
-order-embedding relation, @{text "\<le>o"} (which is the same as being {\em minimal} w.r.t. the
-strict order-embedding relation, @{text "<o"}), among all the well-orders on its field.  *}
-
-definition card_order_on :: "'a set \<Rightarrow> 'a rel \<Rightarrow> bool"
-where
-"card_order_on A r \<equiv> well_order_on A r \<and> (\<forall>r'. well_order_on A r' \<longrightarrow> r \<le>o r')"
-
-
-abbreviation "Card_order r \<equiv> card_order_on (Field r) r"
-abbreviation "card_order r \<equiv> card_order_on UNIV r"
-
-
-lemma card_order_on_well_order_on:
-assumes "card_order_on A r"
-shows "well_order_on A r"
-using assms unfolding card_order_on_def by simp
-
-
-lemma card_order_on_Card_order:
-"card_order_on A r \<Longrightarrow> A = Field r \<and> Card_order r"
-unfolding card_order_on_def using well_order_on_Field by blast
-
-
-text{* The existence of a cardinal relation on any given set (which will mean
-that any set has a cardinal) follows from two facts:
-\begin{itemize}
-\item Zermelo's theorem (proved in @{text "Zorn.thy"} as theorem @{text "well_order_on"}),
-which states that on any given set there exists a well-order;
-\item The well-founded-ness of @{text "<o"}, ensuring that then there exists a minimal
-such well-order, i.e., a cardinal order.
-\end{itemize}
-*}
-
-
-theorem card_order_on: "\<exists>r. card_order_on A r"
-proof-
-  obtain R where R_def: "R = {r. well_order_on A r}" by blast
-  have 1: "R \<noteq> {} \<and> (\<forall>r \<in> R. Well_order r)"
-  using well_order_on[of A] R_def well_order_on_Well_order by blast
-  hence "\<exists>r \<in> R. \<forall>r' \<in> R. r \<le>o r'"
-  using  exists_minim_Well_order[of R] by auto
-  thus ?thesis using R_def unfolding card_order_on_def by auto
-qed
-
-
-lemma card_order_on_ordIso:
-assumes CO: "card_order_on A r" and CO': "card_order_on A r'"
-shows "r =o r'"
-using assms unfolding card_order_on_def
-using ordIso_iff_ordLeq by blast
-
-
-lemma Card_order_ordIso:
-assumes CO: "Card_order r" and ISO: "r' =o r"
-shows "Card_order r'"
-using ISO unfolding ordIso_def
-proof(unfold card_order_on_def, auto)
-  fix p' assume "well_order_on (Field r') p'"
-  hence 0: "Well_order p' \<and> Field p' = Field r'"
-  using well_order_on_Well_order by blast
-  obtain f where 1: "iso r' r f" and 2: "Well_order r \<and> Well_order r'"
-  using ISO unfolding ordIso_def by auto
-  hence 3: "inj_on f (Field r') \<and> f ` (Field r') = Field r"
-  by (auto simp add: iso_iff embed_inj_on)
-  let ?p = "dir_image p' f"
-  have 4: "p' =o ?p \<and> Well_order ?p"
-  using 0 2 3 by (auto simp add: dir_image_ordIso Well_order_dir_image)
-  moreover have "Field ?p =  Field r"
-  using 0 3 by (auto simp add: dir_image_Field2 order_on_defs)
-  ultimately have "well_order_on (Field r) ?p" by auto
-  hence "r \<le>o ?p" using CO unfolding card_order_on_def by auto
-  thus "r' \<le>o p'"
-  using ISO 4 ordLeq_ordIso_trans ordIso_ordLeq_trans ordIso_symmetric by blast
-qed
-
-
-lemma Card_order_ordIso2:
-assumes CO: "Card_order r" and ISO: "r =o r'"
-shows "Card_order r'"
-using assms Card_order_ordIso ordIso_symmetric by blast
-
-
-subsection {* Cardinal of a set *}
-
-
-text{* We define the cardinal of set to be {\em some} cardinal order on that set.
-We shall prove that this notion is unique up to order isomorphism, meaning
-that order isomorphism shall be the true identity of cardinals.  *}
-
-
-definition card_of :: "'a set \<Rightarrow> 'a rel" ("|_|" )
-where "card_of A = (SOME r. card_order_on A r)"
-
-
-lemma card_of_card_order_on: "card_order_on A |A|"
-unfolding card_of_def by (auto simp add: card_order_on someI_ex)
-
-
-lemma card_of_well_order_on: "well_order_on A |A|"
-using card_of_card_order_on card_order_on_def by blast
-
-
-lemma Field_card_of: "Field |A| = A"
-using card_of_card_order_on[of A] unfolding card_order_on_def
-using well_order_on_Field by blast
-
-
-lemma card_of_Card_order: "Card_order |A|"
-by (simp only: card_of_card_order_on Field_card_of)
-
-
-corollary ordIso_card_of_imp_Card_order:
-"r =o |A| \<Longrightarrow> Card_order r"
-using card_of_Card_order Card_order_ordIso by blast
-
-
-lemma card_of_Well_order: "Well_order |A|"
-using card_of_Card_order unfolding card_order_on_def by auto
-
-
-lemma card_of_refl: "|A| =o |A|"
-using card_of_Well_order ordIso_reflexive by blast
-
-
-lemma card_of_least: "well_order_on A r \<Longrightarrow> |A| \<le>o r"
-using card_of_card_order_on unfolding card_order_on_def by blast
-
-
-lemma card_of_ordIso:
-"(\<exists>f. bij_betw f A B) = ( |A| =o |B| )"
-proof(auto)
-  fix f assume *: "bij_betw f A B"
-  then obtain r where "well_order_on B r \<and> |A| =o r"
-  using Well_order_iso_copy card_of_well_order_on by blast
-  hence "|B| \<le>o |A|" using card_of_least
-  ordLeq_ordIso_trans ordIso_symmetric by blast
-  moreover
-  {let ?g = "inv_into A f"
-   have "bij_betw ?g B A" using * bij_betw_inv_into by blast
-   then obtain r where "well_order_on A r \<and> |B| =o r"
-   using Well_order_iso_copy card_of_well_order_on by blast
-   hence "|A| \<le>o |B|" using card_of_least
-   ordLeq_ordIso_trans ordIso_symmetric by blast
-  }
-  ultimately show "|A| =o |B|" using ordIso_iff_ordLeq by blast
-next
-  assume "|A| =o |B|"
-  then obtain f where "iso ( |A| ) ( |B| ) f"
-  unfolding ordIso_def by auto
-  hence "bij_betw f A B" unfolding iso_def Field_card_of by simp
-  thus "\<exists>f. bij_betw f A B" by auto
-qed
-
-
-lemma card_of_ordLeq:
-"(\<exists>f. inj_on f A \<and> f ` A \<le> B) = ( |A| \<le>o |B| )"
-proof(auto)
-  fix f assume *: "inj_on f A" and **: "f ` A \<le> B"
-  {assume "|B| <o |A|"
-   hence "|B| \<le>o |A|" using ordLeq_iff_ordLess_or_ordIso by blast
-   then obtain g where "embed ( |B| ) ( |A| ) g"
-   unfolding ordLeq_def by auto
-   hence 1: "inj_on g B \<and> g ` B \<le> A" using embed_inj_on[of "|B|" "|A|" "g"]
-   card_of_Well_order[of "B"] Field_card_of[of "B"] Field_card_of[of "A"]
-   embed_Field[of "|B|" "|A|" g] by auto
-   obtain h where "bij_betw h A B"
-   using * ** 1 Cantor_Bernstein[of f] by fastforce
-   hence "|A| =o |B|" using card_of_ordIso by blast
-   hence "|A| \<le>o |B|" using ordIso_iff_ordLeq by auto
-  }
-  thus "|A| \<le>o |B|" using ordLess_or_ordLeq[of "|B|" "|A|"]
-  by (auto simp: card_of_Well_order)
-next
-  assume *: "|A| \<le>o |B|"
-  obtain f where "embed ( |A| ) ( |B| ) f"
-  using * unfolding ordLeq_def by auto
-  hence "inj_on f A \<and> f ` A \<le> B" using embed_inj_on[of "|A|" "|B|" f]
-  card_of_Well_order[of "A"] Field_card_of[of "A"] Field_card_of[of "B"]
-  embed_Field[of "|A|" "|B|" f] by auto
-  thus "\<exists>f. inj_on f A \<and> f ` A \<le> B" by auto
-qed
-
-
-lemma card_of_ordLeq2:
-"A \<noteq> {} \<Longrightarrow> (\<exists>g. g ` B = A) = ( |A| \<le>o |B| )"
-using card_of_ordLeq[of A B] inj_on_iff_surj[of A B] by auto
-
-
-lemma card_of_ordLess:
-"(\<not>(\<exists>f. inj_on f A \<and> f ` A \<le> B)) = ( |B| <o |A| )"
-proof-
-  have "(\<not>(\<exists>f. inj_on f A \<and> f ` A \<le> B)) = (\<not> |A| \<le>o |B| )"
-  using card_of_ordLeq by blast
-  also have "\<dots> = ( |B| <o |A| )"
-  using card_of_Well_order[of A] card_of_Well_order[of B]
-        not_ordLeq_iff_ordLess by blast
-  finally show ?thesis .
-qed
-
-
-lemma card_of_ordLess2:
-"B \<noteq> {} \<Longrightarrow> (\<not>(\<exists>f. f ` A = B)) = ( |A| <o |B| )"
-using card_of_ordLess[of B A] inj_on_iff_surj[of B A] by auto
-
-
-lemma card_of_ordIsoI:
-assumes "bij_betw f A B"
-shows "|A| =o |B|"
-using assms unfolding card_of_ordIso[symmetric] by auto
-
-
-lemma card_of_ordLeqI:
-assumes "inj_on f A" and "\<And> a. a \<in> A \<Longrightarrow> f a \<in> B"
-shows "|A| \<le>o |B|"
-using assms unfolding card_of_ordLeq[symmetric] by auto
-
-
-lemma card_of_unique:
-"card_order_on A r \<Longrightarrow> r =o |A|"
-by (simp only: card_order_on_ordIso card_of_card_order_on)
-
-
-lemma card_of_mono1:
-"A \<le> B \<Longrightarrow> |A| \<le>o |B|"
-using inj_on_id[of A] card_of_ordLeq[of A B] by fastforce
-
-
-lemma card_of_mono2:
-assumes "r \<le>o r'"
-shows "|Field r| \<le>o |Field r'|"
-proof-
-  obtain f where
-  1: "well_order_on (Field r) r \<and> well_order_on (Field r) r \<and> embed r r' f"
-  using assms unfolding ordLeq_def
-  by (auto simp add: well_order_on_Well_order)
-  hence "inj_on f (Field r) \<and> f ` (Field r) \<le> Field r'"
-  by (auto simp add: embed_inj_on embed_Field)
-  thus "|Field r| \<le>o |Field r'|" using card_of_ordLeq by blast
-qed
-
-
-lemma card_of_cong: "r =o r' \<Longrightarrow> |Field r| =o |Field r'|"
-by (simp add: ordIso_iff_ordLeq card_of_mono2)
-
-
-lemma card_of_Field_ordLess: "Well_order r \<Longrightarrow> |Field r| \<le>o r"
-using card_of_least card_of_well_order_on well_order_on_Well_order by blast
-
-
-lemma card_of_Field_ordIso:
-assumes "Card_order r"
-shows "|Field r| =o r"
-proof-
-  have "card_order_on (Field r) r"
-  using assms card_order_on_Card_order by blast
-  moreover have "card_order_on (Field r) |Field r|"
-  using card_of_card_order_on by blast
-  ultimately show ?thesis using card_order_on_ordIso by blast
-qed
-
-
-lemma Card_order_iff_ordIso_card_of:
-"Card_order r = (r =o |Field r| )"
-using ordIso_card_of_imp_Card_order card_of_Field_ordIso ordIso_symmetric by blast
-
-
-lemma Card_order_iff_ordLeq_card_of:
-"Card_order r = (r \<le>o |Field r| )"
-proof-
-  have "Card_order r = (r =o |Field r| )"
-  unfolding Card_order_iff_ordIso_card_of by simp
-  also have "... = (r \<le>o |Field r| \<and> |Field r| \<le>o r)"
-  unfolding ordIso_iff_ordLeq by simp
-  also have "... = (r \<le>o |Field r| )"
-  using card_of_Field_ordLess
-  by (auto simp: card_of_Field_ordLess ordLeq_Well_order_simp)
-  finally show ?thesis .
-qed
-
-
-lemma Card_order_iff_Restr_underS:
-assumes "Well_order r"
-shows "Card_order r = (\<forall>a \<in> Field r. Restr r (underS r a) <o |Field r| )"
-using assms unfolding Card_order_iff_ordLeq_card_of
-using ordLeq_iff_ordLess_Restr card_of_Well_order by blast
-
-
-lemma card_of_underS:
-assumes r: "Card_order r" and a: "a : Field r"
-shows "|underS r a| <o r"
-proof-
-  let ?A = "underS r a"  let ?r' = "Restr r ?A"
-  have 1: "Well_order r"
-  using r unfolding card_order_on_def by simp
-  have "Well_order ?r'" using 1 Well_order_Restr by auto
-  moreover have "card_order_on (Field ?r') |Field ?r'|"
-  using card_of_card_order_on .
-  ultimately have "|Field ?r'| \<le>o ?r'"
-  unfolding card_order_on_def by simp
-  moreover have "Field ?r' = ?A"
-  using 1 wo_rel.underS_ofilter Field_Restr_ofilter
-  unfolding wo_rel_def by fastforce
-  ultimately have "|?A| \<le>o ?r'" by simp
-  also have "?r' <o |Field r|"
-  using 1 a r Card_order_iff_Restr_underS by blast
-  also have "|Field r| =o r"
-  using r ordIso_symmetric unfolding Card_order_iff_ordIso_card_of by auto
-  finally show ?thesis .
-qed
-
-
-lemma ordLess_Field:
-assumes "r <o r'"
-shows "|Field r| <o r'"
-proof-
-  have "well_order_on (Field r) r" using assms unfolding ordLess_def
-  by (auto simp add: well_order_on_Well_order)
-  hence "|Field r| \<le>o r" using card_of_least by blast
-  thus ?thesis using assms ordLeq_ordLess_trans by blast
-qed
-
-
-lemma internalize_card_of_ordLeq:
-"( |A| \<le>o r) = (\<exists>B \<le> Field r. |A| =o |B| \<and> |B| \<le>o r)"
-proof
-  assume "|A| \<le>o r"
-  then obtain p where 1: "Field p \<le> Field r \<and> |A| =o p \<and> p \<le>o r"
-  using internalize_ordLeq[of "|A|" r] by blast
-  hence "Card_order p" using card_of_Card_order Card_order_ordIso2 by blast
-  hence "|Field p| =o p" using card_of_Field_ordIso by blast
-  hence "|A| =o |Field p| \<and> |Field p| \<le>o r"
-  using 1 ordIso_equivalence ordIso_ordLeq_trans by blast
-  thus "\<exists>B \<le> Field r. |A| =o |B| \<and> |B| \<le>o r" using 1 by blast
-next
-  assume "\<exists>B \<le> Field r. |A| =o |B| \<and> |B| \<le>o r"
-  thus "|A| \<le>o r" using ordIso_ordLeq_trans by blast
-qed
-
-
-lemma internalize_card_of_ordLeq2:
-"( |A| \<le>o |C| ) = (\<exists>B \<le> C. |A| =o |B| \<and> |B| \<le>o |C| )"
-using internalize_card_of_ordLeq[of "A" "|C|"] Field_card_of[of C] by auto
-
-
-
-subsection {* Cardinals versus set operations on arbitrary sets *}
-
-
-text{* Here we embark in a long journey of simple results showing
-that the standard set-theoretic operations are well-behaved w.r.t. the notion of
-cardinal -- essentially, this means that they preserve the ``cardinal identity"
-@{text "=o"} and are monotonic w.r.t. @{text "\<le>o"}.
-*}
-
-
-lemma card_of_empty: "|{}| \<le>o |A|"
-using card_of_ordLeq inj_on_id by blast
-
-
-lemma card_of_empty1:
-assumes "Well_order r \<or> Card_order r"
-shows "|{}| \<le>o r"
-proof-
-  have "Well_order r" using assms unfolding card_order_on_def by auto
-  hence "|Field r| <=o r"
-  using assms card_of_Field_ordLess by blast
-  moreover have "|{}| \<le>o |Field r|" by (simp add: card_of_empty)
-  ultimately show ?thesis using ordLeq_transitive by blast
-qed
-
-
-corollary Card_order_empty:
-"Card_order r \<Longrightarrow> |{}| \<le>o r" by (simp add: card_of_empty1)
-
-
-lemma card_of_empty2:
-assumes LEQ: "|A| =o |{}|"
-shows "A = {}"
-using assms card_of_ordIso[of A] bij_betw_empty2 by blast
-
-
-lemma card_of_empty3:
-assumes LEQ: "|A| \<le>o |{}|"
-shows "A = {}"
-using assms
-by (simp add: ordIso_iff_ordLeq card_of_empty1 card_of_empty2
-              ordLeq_Well_order_simp)
-
-
-lemma card_of_empty_ordIso:
-"|{}::'a set| =o |{}::'b set|"
-using card_of_ordIso unfolding bij_betw_def inj_on_def by blast
-
-
-lemma card_of_image:
-"|f ` A| <=o |A|"
-proof(cases "A = {}", simp add: card_of_empty)
-  assume "A ~= {}"
-  hence "f ` A ~= {}" by auto
-  thus "|f ` A| \<le>o |A|"
-  using card_of_ordLeq2[of "f ` A" A] by auto
-qed
-
-
-lemma surj_imp_ordLeq:
-assumes "B <= f ` A"
-shows "|B| <=o |A|"
-proof-
-  have "|B| <=o |f ` A|" using assms card_of_mono1 by auto
-  thus ?thesis using card_of_image ordLeq_transitive by blast
-qed
-
-
-lemma card_of_ordLeqI2:
-assumes "B \<subseteq> f ` A"
-shows "|B| \<le>o |A|"
-using assms by (metis surj_imp_ordLeq)
-
-
-lemma card_of_singl_ordLeq:
-assumes "A \<noteq> {}"
-shows "|{b}| \<le>o |A|"
-proof-
-  obtain a where *: "a \<in> A" using assms by auto
-  let ?h = "\<lambda> b'::'b. if b' = b then a else undefined"
-  have "inj_on ?h {b} \<and> ?h ` {b} \<le> A"
-  using * unfolding inj_on_def by auto
-  thus ?thesis using card_of_ordLeq by fast
-qed
-
-
-corollary Card_order_singl_ordLeq:
-"\<lbrakk>Card_order r; Field r \<noteq> {}\<rbrakk> \<Longrightarrow> |{b}| \<le>o r"
-using card_of_singl_ordLeq[of "Field r" b]
-      card_of_Field_ordIso[of r] ordLeq_ordIso_trans by blast
-
-
-lemma card_of_Pow: "|A| <o |Pow A|"
-using card_of_ordLess2[of "Pow A" A]  Cantors_paradox[of A]
-      Pow_not_empty[of A] by auto
-
-
-corollary Card_order_Pow:
-"Card_order r \<Longrightarrow> r <o |Pow(Field r)|"
-using card_of_Pow card_of_Field_ordIso ordIso_ordLess_trans ordIso_symmetric by blast
-
-
-lemma card_of_Plus1: "|A| \<le>o |A <+> B|"
-proof-
-  have "Inl ` A \<le> A <+> B" by auto
-  thus ?thesis using inj_Inl[of A] card_of_ordLeq by blast
-qed
-
-
-corollary Card_order_Plus1:
-"Card_order r \<Longrightarrow> r \<le>o |(Field r) <+> B|"
-using card_of_Plus1 card_of_Field_ordIso ordIso_ordLeq_trans ordIso_symmetric by blast
-
-
-lemma card_of_Plus2: "|B| \<le>o |A <+> B|"
-proof-
-  have "Inr ` B \<le> A <+> B" by auto
-  thus ?thesis using inj_Inr[of B] card_of_ordLeq by blast
-qed
-
-
-corollary Card_order_Plus2:
-"Card_order r \<Longrightarrow> r \<le>o |A <+> (Field r)|"
-using card_of_Plus2 card_of_Field_ordIso ordIso_ordLeq_trans ordIso_symmetric by blast
-
-
-lemma card_of_Plus_empty1: "|A| =o |A <+> {}|"
-proof-
-  have "bij_betw Inl A (A <+> {})" unfolding bij_betw_def inj_on_def by auto
-  thus ?thesis using card_of_ordIso by auto
-qed
-
-
-lemma card_of_Plus_empty2: "|A| =o |{} <+> A|"
-proof-
-  have "bij_betw Inr A ({} <+> A)" unfolding bij_betw_def inj_on_def by auto
-  thus ?thesis using card_of_ordIso by auto
-qed
-
-
-lemma card_of_Plus_commute: "|A <+> B| =o |B <+> A|"
-proof-
-  let ?f = "\<lambda>(c::'a + 'b). case c of Inl a \<Rightarrow> Inr a
-                                   | Inr b \<Rightarrow> Inl b"
-  have "bij_betw ?f (A <+> B) (B <+> A)"
-  unfolding bij_betw_def inj_on_def by force
-  thus ?thesis using card_of_ordIso by blast
-qed
-
-
-lemma card_of_Plus_assoc:
-fixes A :: "'a set" and B :: "'b set" and C :: "'c set"
-shows "|(A <+> B) <+> C| =o |A <+> B <+> C|"
-proof -
-  def f \<equiv> "\<lambda>(k::('a + 'b) + 'c).
-  case k of Inl ab \<Rightarrow> (case ab of Inl a \<Rightarrow> Inl a
-                                 |Inr b \<Rightarrow> Inr (Inl b))
-           |Inr c \<Rightarrow> Inr (Inr c)"
-  have "A <+> B <+> C \<subseteq> f ` ((A <+> B) <+> C)"
-  proof
-    fix x assume x: "x \<in> A <+> B <+> C"
-    show "x \<in> f ` ((A <+> B) <+> C)"
-    proof(cases x)
-      case (Inl a)
-      hence "a \<in> A" "x = f (Inl (Inl a))"
-      using x unfolding f_def by auto
-      thus ?thesis by auto
-    next
-      case (Inr bc) note 1 = Inr show ?thesis
-      proof(cases bc)
-        case (Inl b)
-        hence "b \<in> B" "x = f (Inl (Inr b))"
-        using x 1 unfolding f_def by auto
-        thus ?thesis by auto
-      next
-        case (Inr c)
-        hence "c \<in> C" "x = f (Inr c)"
-        using x 1 unfolding f_def by auto
-        thus ?thesis by auto
-      qed
-    qed
-  qed
-  hence "bij_betw f ((A <+> B) <+> C) (A <+> B <+> C)"
-  unfolding bij_betw_def inj_on_def f_def by fastforce
-  thus ?thesis using card_of_ordIso by blast
-qed
-
-
-lemma card_of_Plus_mono1:
-assumes "|A| \<le>o |B|"
-shows "|A <+> C| \<le>o |B <+> C|"
-proof-
-  obtain f where 1: "inj_on f A \<and> f ` A \<le> B"
-  using assms card_of_ordLeq[of A] by fastforce
-  obtain g where g_def:
-  "g = (\<lambda>d. case d of Inl a \<Rightarrow> Inl(f a) | Inr (c::'c) \<Rightarrow> Inr c)" by blast
-  have "inj_on g (A <+> C) \<and> g ` (A <+> C) \<le> (B <+> C)"
-  proof-
-    {fix d1 and d2 assume "d1 \<in> A <+> C \<and> d2 \<in> A <+> C" and
-                          "g d1 = g d2"
-     hence "d1 = d2" using 1 unfolding inj_on_def g_def by force
-    }
-    moreover
-    {fix d assume "d \<in> A <+> C"
-     hence "g d \<in> B <+> C"  using 1
-     by(case_tac d, auto simp add: g_def)
-    }
-    ultimately show ?thesis unfolding inj_on_def by auto
-  qed
-  thus ?thesis using card_of_ordLeq by metis
-qed
-
-
-corollary ordLeq_Plus_mono1:
-assumes "r \<le>o r'"
-shows "|(Field r) <+> C| \<le>o |(Field r') <+> C|"
-using assms card_of_mono2 card_of_Plus_mono1 by blast
-
-
-lemma card_of_Plus_mono2:
-assumes "|A| \<le>o |B|"
-shows "|C <+> A| \<le>o |C <+> B|"
-using assms card_of_Plus_mono1[of A B C]
-      card_of_Plus_commute[of C A]  card_of_Plus_commute[of B C]
-      ordIso_ordLeq_trans[of "|C <+> A|"] ordLeq_ordIso_trans[of "|C <+> A|"]
-by blast
-
-
-corollary ordLeq_Plus_mono2:
-assumes "r \<le>o r'"
-shows "|A <+> (Field r)| \<le>o |A <+> (Field r')|"
-using assms card_of_mono2 card_of_Plus_mono2 by blast
-
-
-lemma card_of_Plus_mono:
-assumes "|A| \<le>o |B|" and "|C| \<le>o |D|"
-shows "|A <+> C| \<le>o |B <+> D|"
-using assms card_of_Plus_mono1[of A B C] card_of_Plus_mono2[of C D B]
-      ordLeq_transitive[of "|A <+> C|"] by blast
-
-
-corollary ordLeq_Plus_mono:
-assumes "r \<le>o r'" and "p \<le>o p'"
-shows "|(Field r) <+> (Field p)| \<le>o |(Field r') <+> (Field p')|"
-using assms card_of_mono2[of r r'] card_of_mono2[of p p'] card_of_Plus_mono by blast
-
-
-lemma card_of_Plus_cong1:
-assumes "|A| =o |B|"
-shows "|A <+> C| =o |B <+> C|"
-using assms by (simp add: ordIso_iff_ordLeq card_of_Plus_mono1)
-
-
-corollary ordIso_Plus_cong1:
-assumes "r =o r'"
-shows "|(Field r) <+> C| =o |(Field r') <+> C|"
-using assms card_of_cong card_of_Plus_cong1 by blast
-
-
-lemma card_of_Plus_cong2:
-assumes "|A| =o |B|"
-shows "|C <+> A| =o |C <+> B|"
-using assms by (simp add: ordIso_iff_ordLeq card_of_Plus_mono2)
-
-
-corollary ordIso_Plus_cong2:
-assumes "r =o r'"
-shows "|A <+> (Field r)| =o |A <+> (Field r')|"
-using assms card_of_cong card_of_Plus_cong2 by blast
-
-
-lemma card_of_Plus_cong:
-assumes "|A| =o |B|" and "|C| =o |D|"
-shows "|A <+> C| =o |B <+> D|"
-using assms by (simp add: ordIso_iff_ordLeq card_of_Plus_mono)
-
-
-corollary ordIso_Plus_cong:
-assumes "r =o r'" and "p =o p'"
-shows "|(Field r) <+> (Field p)| =o |(Field r') <+> (Field p')|"
-using assms card_of_cong[of r r'] card_of_cong[of p p'] card_of_Plus_cong by blast
-
-
-lemma card_of_Un_Plus_ordLeq:
-"|A \<union> B| \<le>o |A <+> B|"
-proof-
-   let ?f = "\<lambda> c. if c \<in> A then Inl c else Inr c"
-   have "inj_on ?f (A \<union> B) \<and> ?f ` (A \<union> B) \<le> A <+> B"
-   unfolding inj_on_def by auto
-   thus ?thesis using card_of_ordLeq by blast
-qed
-
-
-lemma card_of_Times1:
-assumes "A \<noteq> {}"
-shows "|B| \<le>o |B \<times> A|"
-proof(cases "B = {}", simp add: card_of_empty)
-  assume *: "B \<noteq> {}"
-  have "fst `(B \<times> A) = B" unfolding image_def using assms by auto
-  thus ?thesis using inj_on_iff_surj[of B "B \<times> A"]
-                     card_of_ordLeq[of B "B \<times> A"] * by blast
-qed
-
-
-lemma card_of_Times_commute: "|A \<times> B| =o |B \<times> A|"
-proof-
-  let ?f = "\<lambda>(a::'a,b::'b). (b,a)"
-  have "bij_betw ?f (A \<times> B) (B \<times> A)"
-  unfolding bij_betw_def inj_on_def by auto
-  thus ?thesis using card_of_ordIso by blast
-qed
-
-
-lemma card_of_Times2:
-assumes "A \<noteq> {}"   shows "|B| \<le>o |A \<times> B|"
-using assms card_of_Times1[of A B] card_of_Times_commute[of B A]
-      ordLeq_ordIso_trans by blast
-
-
-corollary Card_order_Times1:
-"\<lbrakk>Card_order r; B \<noteq> {}\<rbrakk> \<Longrightarrow> r \<le>o |(Field r) \<times> B|"
-using card_of_Times1[of B] card_of_Field_ordIso
-      ordIso_ordLeq_trans ordIso_symmetric by blast
-
-
-corollary Card_order_Times2:
-"\<lbrakk>Card_order r; A \<noteq> {}\<rbrakk> \<Longrightarrow> r \<le>o |A \<times> (Field r)|"
-using card_of_Times2[of A] card_of_Field_ordIso
-      ordIso_ordLeq_trans ordIso_symmetric by blast
-
-
-lemma card_of_Times3: "|A| \<le>o |A \<times> A|"
-using card_of_Times1[of A]
-by(cases "A = {}", simp add: card_of_empty, blast)
-
-
-lemma card_of_Plus_Times_bool: "|A <+> A| =o |A \<times> (UNIV::bool set)|"
-proof-
-  let ?f = "\<lambda>c::'a + 'a. case c of Inl a \<Rightarrow> (a,True)
-                                  |Inr a \<Rightarrow> (a,False)"
-  have "bij_betw ?f (A <+> A) (A \<times> (UNIV::bool set))"
-  proof-
-    {fix  c1 and c2 assume "?f c1 = ?f c2"
-     hence "c1 = c2"
-     by(case_tac "c1", case_tac "c2", auto, case_tac "c2", auto)
-    }
-    moreover
-    {fix c assume "c \<in> A <+> A"
-     hence "?f c \<in> A \<times> (UNIV::bool set)"
-     by(case_tac c, auto)
-    }
-    moreover
-    {fix a bl assume *: "(a,bl) \<in> A \<times> (UNIV::bool set)"
-     have "(a,bl) \<in> ?f ` ( A <+> A)"
-     proof(cases bl)
-       assume bl hence "?f(Inl a) = (a,bl)" by auto
-       thus ?thesis using * by force
-     next
-       assume "\<not> bl" hence "?f(Inr a) = (a,bl)" by auto
-       thus ?thesis using * by force
-     qed
-    }
-    ultimately show ?thesis unfolding bij_betw_def inj_on_def by auto
-  qed
-  thus ?thesis using card_of_ordIso by blast
-qed
-
-
-lemma card_of_Times_mono1:
-assumes "|A| \<le>o |B|"
-shows "|A \<times> C| \<le>o |B \<times> C|"
-proof-
-  obtain f where 1: "inj_on f A \<and> f ` A \<le> B"
-  using assms card_of_ordLeq[of A] by fastforce
-  obtain g where g_def:
-  "g = (\<lambda>(a,c::'c). (f a,c))" by blast
-  have "inj_on g (A \<times> C) \<and> g ` (A \<times> C) \<le> (B \<times> C)"
-  using 1 unfolding inj_on_def using g_def by auto
-  thus ?thesis using card_of_ordLeq by metis
-qed
-
-
-corollary ordLeq_Times_mono1:
-assumes "r \<le>o r'"
-shows "|(Field r) \<times> C| \<le>o |(Field r') \<times> C|"
-using assms card_of_mono2 card_of_Times_mono1 by blast
-
-
-lemma card_of_Times_mono2:
-assumes "|A| \<le>o |B|"
-shows "|C \<times> A| \<le>o |C \<times> B|"
-using assms card_of_Times_mono1[of A B C]
-      card_of_Times_commute[of C A]  card_of_Times_commute[of B C]
-      ordIso_ordLeq_trans[of "|C \<times> A|"] ordLeq_ordIso_trans[of "|C \<times> A|"]
-by blast
-
-
-corollary ordLeq_Times_mono2:
-assumes "r \<le>o r'"
-shows "|A \<times> (Field r)| \<le>o |A \<times> (Field r')|"
-using assms card_of_mono2 card_of_Times_mono2 by blast
-
-
-lemma card_of_Sigma_mono1:
-assumes "\<forall>i \<in> I. |A i| \<le>o |B i|"
-shows "|SIGMA i : I. A i| \<le>o |SIGMA i : I. B i|"
-proof-
-  have "\<forall>i. i \<in> I \<longrightarrow> (\<exists>f. inj_on f (A i) \<and> f ` (A i) \<le> B i)"
-  using assms by (auto simp add: card_of_ordLeq)
-  with choice[of "\<lambda> i f. i \<in> I \<longrightarrow> inj_on f (A i) \<and> f ` (A i) \<le> B i"]
-  obtain F where 1: "\<forall>i \<in> I. inj_on (F i) (A i) \<and> (F i) ` (A i) \<le> B i" by metis
-  obtain g where g_def: "g = (\<lambda>(i,a::'b). (i,F i a))" by blast
-  have "inj_on g (Sigma I A) \<and> g ` (Sigma I A) \<le> (Sigma I B)"
-  using 1 unfolding inj_on_def using g_def by force
-  thus ?thesis using card_of_ordLeq by metis
-qed
-
-
-corollary card_of_Sigma_Times:
-"\<forall>i \<in> I. |A i| \<le>o |B| \<Longrightarrow> |SIGMA i : I. A i| \<le>o |I \<times> B|"
-using card_of_Sigma_mono1[of I A "\<lambda>i. B"] .
-
-
-lemma card_of_UNION_Sigma:
-"|\<Union>i \<in> I. A i| \<le>o |SIGMA i : I. A i|"
-using Ex_inj_on_UNION_Sigma[of I A] card_of_ordLeq by metis
-
-
-lemma card_of_bool:
-assumes "a1 \<noteq> a2"
-shows "|UNIV::bool set| =o |{a1,a2}|"
-proof-
-  let ?f = "\<lambda> bl. case bl of True \<Rightarrow> a1 | False \<Rightarrow> a2"
-  have "bij_betw ?f UNIV {a1,a2}"
-  proof-
-    {fix bl1 and bl2 assume "?f  bl1 = ?f bl2"
-     hence "bl1 = bl2" using assms by (case_tac bl1, case_tac bl2, auto)
-    }
-    moreover
-    {fix bl have "?f bl \<in> {a1,a2}" by (case_tac bl, auto)
-    }
-    moreover
-    {fix a assume *: "a \<in> {a1,a2}"
-     have "a \<in> ?f ` UNIV"
-     proof(cases "a = a1")
-       assume "a = a1"
-       hence "?f True = a" by auto  thus ?thesis by blast
-     next
-       assume "a \<noteq> a1" hence "a = a2" using * by auto
-       hence "?f False = a" by auto  thus ?thesis by blast
-     qed
-    }
-    ultimately show ?thesis unfolding bij_betw_def inj_on_def
-    by (metis image_subsetI order_eq_iff subsetI)
-  qed
-  thus ?thesis using card_of_ordIso by blast
-qed
-
-
-lemma card_of_Plus_Times_aux:
-assumes A2: "a1 \<noteq> a2 \<and> {a1,a2} \<le> A" and
-        LEQ: "|A| \<le>o |B|"
-shows "|A <+> B| \<le>o |A \<times> B|"
-proof-
-  have 1: "|UNIV::bool set| \<le>o |A|"
-  using A2 card_of_mono1[of "{a1,a2}"] card_of_bool[of a1 a2]
-        ordIso_ordLeq_trans[of "|UNIV::bool set|"] by metis
-  (*  *)
-  have "|A <+> B| \<le>o |B <+> B|"
-  using LEQ card_of_Plus_mono1 by blast
-  moreover have "|B <+> B| =o |B \<times> (UNIV::bool set)|"
-  using card_of_Plus_Times_bool by blast
-  moreover have "|B \<times> (UNIV::bool set)| \<le>o |B \<times> A|"
-  using 1 by (simp add: card_of_Times_mono2)
-  moreover have " |B \<times> A| =o |A \<times> B|"
-  using card_of_Times_commute by blast
-  ultimately show "|A <+> B| \<le>o |A \<times> B|"
-  using ordLeq_ordIso_trans[of "|A <+> B|" "|B <+> B|" "|B \<times> (UNIV::bool set)|"]
-        ordLeq_transitive[of "|A <+> B|" "|B \<times> (UNIV::bool set)|" "|B \<times> A|"]
-        ordLeq_ordIso_trans[of "|A <+> B|" "|B \<times> A|" "|A \<times> B|"]
-  by blast
-qed
-
-
-lemma card_of_Plus_Times:
-assumes A2: "a1 \<noteq> a2 \<and> {a1,a2} \<le> A" and
-        B2: "b1 \<noteq> b2 \<and> {b1,b2} \<le> B"
-shows "|A <+> B| \<le>o |A \<times> B|"
-proof-
-  {assume "|A| \<le>o |B|"
-   hence ?thesis using assms by (auto simp add: card_of_Plus_Times_aux)
-  }
-  moreover
-  {assume "|B| \<le>o |A|"
-   hence "|B <+> A| \<le>o |B \<times> A|"
-   using assms by (auto simp add: card_of_Plus_Times_aux)
-   hence ?thesis
-   using card_of_Plus_commute card_of_Times_commute
-         ordIso_ordLeq_trans ordLeq_ordIso_trans by metis
-  }
-  ultimately show ?thesis
-  using card_of_Well_order[of A] card_of_Well_order[of B]
-        ordLeq_total[of "|A|"] by metis
-qed
-
-
-lemma card_of_ordLeq_finite:
-assumes "|A| \<le>o |B|" and "finite B"
-shows "finite A"
-using assms unfolding ordLeq_def
-using embed_inj_on[of "|A|" "|B|"]  embed_Field[of "|A|" "|B|"]
-      Field_card_of[of "A"] Field_card_of[of "B"] inj_on_finite[of _ "A" "B"] by fastforce
-
-
-lemma card_of_ordLeq_infinite:
-assumes "|A| \<le>o |B|" and "\<not> finite A"
-shows "\<not> finite B"
-using assms card_of_ordLeq_finite by auto
-
-
-lemma card_of_ordIso_finite:
-assumes "|A| =o |B|"
-shows "finite A = finite B"
-using assms unfolding ordIso_def iso_def[abs_def]
-by (auto simp: bij_betw_finite Field_card_of)
-
-
-lemma card_of_ordIso_finite_Field:
-assumes "Card_order r" and "r =o |A|"
-shows "finite(Field r) = finite A"
-using assms card_of_Field_ordIso card_of_ordIso_finite ordIso_equivalence by blast
-
-
-subsection {* Cardinals versus set operations involving infinite sets *}
-
-
-text{* Here we show that, for infinite sets, most set-theoretic constructions
-do not increase the cardinality.  The cornerstone for this is
-theorem @{text "Card_order_Times_same_infinite"}, which states that self-product
-does not increase cardinality -- the proof of this fact adapts a standard
-set-theoretic argument, as presented, e.g., in the proof of theorem 1.5.11
-at page 47 in \cite{card-book}. Then everything else follows fairly easily.  *}
-
-
-lemma infinite_iff_card_of_nat:
-"\<not> finite A \<longleftrightarrow> ( |UNIV::nat set| \<le>o |A| )"
-unfolding infinite_iff_countable_subset card_of_ordLeq ..
-
-text{* The next two results correspond to the ZF fact that all infinite cardinals are
-limit ordinals: *}
-
-lemma Card_order_infinite_not_under:
-assumes CARD: "Card_order r" and INF: "\<not>finite (Field r)"
-shows "\<not> (\<exists>a. Field r = under r a)"
-proof(auto)
-  have 0: "Well_order r \<and> wo_rel r \<and> Refl r"
-  using CARD unfolding wo_rel_def card_order_on_def order_on_defs by auto
-  fix a assume *: "Field r = under r a"
-  show False
-  proof(cases "a \<in> Field r")
-    assume Case1: "a \<notin> Field r"
-    hence "under r a = {}" unfolding Field_def under_def by auto
-    thus False using INF *  by auto
-  next
-    let ?r' = "Restr r (underS r a)"
-    assume Case2: "a \<in> Field r"
-    hence 1: "under r a = underS r a \<union> {a} \<and> a \<notin> underS r a"
-    using 0 Refl_under_underS underS_notIn by metis
-    have 2: "wo_rel.ofilter r (underS r a) \<and> underS r a < Field r"
-    using 0 wo_rel.underS_ofilter * 1 Case2 by fast
-    hence "?r' <o r" using 0 using ofilter_ordLess by blast
-    moreover
-    have "Field ?r' = underS r a \<and> Well_order ?r'"
-    using  2 0 Field_Restr_ofilter[of r] Well_order_Restr[of r] by blast
-    ultimately have "|underS r a| <o r" using ordLess_Field[of ?r'] by auto
-    moreover have "|under r a| =o r" using * CARD card_of_Field_ordIso[of r] by auto
-    ultimately have "|underS r a| <o |under r a|"
-    using ordIso_symmetric ordLess_ordIso_trans by blast
-    moreover
-    {have "\<exists>f. bij_betw f (under r a) (underS r a)"
-     using infinite_imp_bij_betw[of "Field r" a] INF * 1 by auto
-     hence "|under r a| =o |underS r a|" using card_of_ordIso by blast
-    }
-    ultimately show False using not_ordLess_ordIso ordIso_symmetric by blast
-  qed
-qed
-
-
-lemma infinite_Card_order_limit:
-assumes r: "Card_order r" and "\<not>finite (Field r)"
-and a: "a : Field r"
-shows "EX b : Field r. a \<noteq> b \<and> (a,b) : r"
-proof-
-  have "Field r \<noteq> under r a"
-  using assms Card_order_infinite_not_under by blast
-  moreover have "under r a \<le> Field r"
-  using under_Field .
-  ultimately have "under r a < Field r" by blast
-  then obtain b where 1: "b : Field r \<and> ~ (b,a) : r"
-  unfolding under_def by blast
-  moreover have ba: "b \<noteq> a"
-  using 1 r unfolding card_order_on_def well_order_on_def
-  linear_order_on_def partial_order_on_def preorder_on_def refl_on_def by auto
-  ultimately have "(a,b) : r"
-  using a r unfolding card_order_on_def well_order_on_def linear_order_on_def
-  total_on_def by blast
-  thus ?thesis using 1 ba by auto
-qed
-
-
-theorem Card_order_Times_same_infinite:
-assumes CO: "Card_order r" and INF: "\<not>finite(Field r)"
-shows "|Field r \<times> Field r| \<le>o r"
-proof-
-  obtain phi where phi_def:
-  "phi = (\<lambda>r::'a rel. Card_order r \<and> \<not>finite(Field r) \<and>
-                      \<not> |Field r \<times> Field r| \<le>o r )" by blast
-  have temp1: "\<forall>r. phi r \<longrightarrow> Well_order r"
-  unfolding phi_def card_order_on_def by auto
-  have Ft: "\<not>(\<exists>r. phi r)"
-  proof
-    assume "\<exists>r. phi r"
-    hence "{r. phi r} \<noteq> {} \<and> {r. phi r} \<le> {r. Well_order r}"
-    using temp1 by auto
-    then obtain r where 1: "phi r" and 2: "\<forall>r'. phi r' \<longrightarrow> r \<le>o r'" and
-                   3: "Card_order r \<and> Well_order r"
-    using exists_minim_Well_order[of "{r. phi r}"] temp1 phi_def by blast
-    let ?A = "Field r"  let ?r' = "bsqr r"
-    have 4: "Well_order ?r' \<and> Field ?r' = ?A \<times> ?A \<and> |?A| =o r"
-    using 3 bsqr_Well_order Field_bsqr card_of_Field_ordIso by blast
-    have 5: "Card_order |?A \<times> ?A| \<and> Well_order |?A \<times> ?A|"
-    using card_of_Card_order card_of_Well_order by blast
-    (*  *)
-    have "r <o |?A \<times> ?A|"
-    using 1 3 5 ordLess_or_ordLeq unfolding phi_def by blast
-    moreover have "|?A \<times> ?A| \<le>o ?r'"
-    using card_of_least[of "?A \<times> ?A"] 4 by auto
-    ultimately have "r <o ?r'" using ordLess_ordLeq_trans by auto
-    then obtain f where 6: "embed r ?r' f" and 7: "\<not> bij_betw f ?A (?A \<times> ?A)"
-    unfolding ordLess_def embedS_def[abs_def]
-    by (auto simp add: Field_bsqr)
-    let ?B = "f ` ?A"
-    have "|?A| =o |?B|"
-    using 3 6 embed_inj_on inj_on_imp_bij_betw card_of_ordIso by blast
-    hence 8: "r =o |?B|" using 4 ordIso_transitive ordIso_symmetric by blast
-    (*  *)
-    have "wo_rel.ofilter ?r' ?B"
-    using 6 embed_Field_ofilter 3 4 by blast
-    hence "wo_rel.ofilter ?r' ?B \<and> ?B \<noteq> ?A \<times> ?A \<and> ?B \<noteq> Field ?r'"
-    using 7 unfolding bij_betw_def using 6 3 embed_inj_on 4 by auto
-    hence temp2: "wo_rel.ofilter ?r' ?B \<and> ?B < ?A \<times> ?A"
-    using 4 wo_rel_def[of ?r'] wo_rel.ofilter_def[of ?r' ?B] by blast
-    have "\<not> (\<exists>a. Field r = under r a)"
-    using 1 unfolding phi_def using Card_order_infinite_not_under[of r] by auto
-    then obtain A1 where temp3: "wo_rel.ofilter r A1 \<and> A1 < ?A" and 9: "?B \<le> A1 \<times> A1"
-    using temp2 3 bsqr_ofilter[of r ?B] by blast
-    hence "|?B| \<le>o |A1 \<times> A1|" using card_of_mono1 by blast
-    hence 10: "r \<le>o |A1 \<times> A1|" using 8 ordIso_ordLeq_trans by blast
-    let ?r1 = "Restr r A1"
-    have "?r1 <o r" using temp3 ofilter_ordLess 3 by blast
-    moreover
-    {have "well_order_on A1 ?r1" using 3 temp3 well_order_on_Restr by blast
-     hence "|A1| \<le>o ?r1" using 3 Well_order_Restr card_of_least by blast
-    }
-    ultimately have 11: "|A1| <o r" using ordLeq_ordLess_trans by blast
-    (*  *)
-    have "\<not> finite (Field r)" using 1 unfolding phi_def by simp
-    hence "\<not> finite ?B" using 8 3 card_of_ordIso_finite_Field[of r ?B] by blast
-    hence "\<not> finite A1" using 9 finite_cartesian_product finite_subset by metis
-    moreover have temp4: "Field |A1| = A1 \<and> Well_order |A1| \<and> Card_order |A1|"
-    using card_of_Card_order[of A1] card_of_Well_order[of A1]
-    by (simp add: Field_card_of)
-    moreover have "\<not> r \<le>o | A1 |"
-    using temp4 11 3 using not_ordLeq_iff_ordLess by blast
-    ultimately have "\<not> finite(Field |A1| ) \<and> Card_order |A1| \<and> \<not> r \<le>o | A1 |"
-    by (simp add: card_of_card_order_on)
-    hence "|Field |A1| \<times> Field |A1| | \<le>o |A1|"
-    using 2 unfolding phi_def by blast
-    hence "|A1 \<times> A1 | \<le>o |A1|" using temp4 by auto
-    hence "r \<le>o |A1|" using 10 ordLeq_transitive by blast
-    thus False using 11 not_ordLess_ordLeq by auto
-  qed
-  thus ?thesis using assms unfolding phi_def by blast
-qed
-
-
-corollary card_of_Times_same_infinite:
-assumes "\<not>finite A"
-shows "|A \<times> A| =o |A|"
-proof-
-  let ?r = "|A|"
-  have "Field ?r = A \<and> Card_order ?r"
-  using Field_card_of card_of_Card_order[of A] by fastforce
-  hence "|A \<times> A| \<le>o |A|"
-  using Card_order_Times_same_infinite[of ?r] assms by auto
-  thus ?thesis using card_of_Times3 ordIso_iff_ordLeq by blast
-qed
-
-
-lemma card_of_Times_infinite:
-assumes INF: "\<not>finite A" and NE: "B \<noteq> {}" and LEQ: "|B| \<le>o |A|"
-shows "|A \<times> B| =o |A| \<and> |B \<times> A| =o |A|"
-proof-
-  have "|A| \<le>o |A \<times> B| \<and> |A| \<le>o |B \<times> A|"
-  using assms by (simp add: card_of_Times1 card_of_Times2)
-  moreover
-  {have "|A \<times> B| \<le>o |A \<times> A| \<and> |B \<times> A| \<le>o |A \<times> A|"
-   using LEQ card_of_Times_mono1 card_of_Times_mono2 by blast
-   moreover have "|A \<times> A| =o |A|" using INF card_of_Times_same_infinite by blast
-   ultimately have "|A \<times> B| \<le>o |A| \<and> |B \<times> A| \<le>o |A|"
-   using ordLeq_ordIso_trans[of "|A \<times> B|"] ordLeq_ordIso_trans[of "|B \<times> A|"] by auto
-  }
-  ultimately show ?thesis by (simp add: ordIso_iff_ordLeq)
-qed
-
-
-corollary Card_order_Times_infinite:
-assumes INF: "\<not>finite(Field r)" and CARD: "Card_order r" and
-        NE: "Field p \<noteq> {}" and LEQ: "p \<le>o r"
-shows "| (Field r) \<times> (Field p) | =o r \<and> | (Field p) \<times> (Field r) | =o r"
-proof-
-  have "|Field r \<times> Field p| =o |Field r| \<and> |Field p \<times> Field r| =o |Field r|"
-  using assms by (simp add: card_of_Times_infinite card_of_mono2)
-  thus ?thesis
-  using assms card_of_Field_ordIso[of r]
-        ordIso_transitive[of "|Field r \<times> Field p|"]
-        ordIso_transitive[of _ "|Field r|"] by blast
-qed
-
-
-lemma card_of_Sigma_ordLeq_infinite:
-assumes INF: "\<not>finite B" and
-        LEQ_I: "|I| \<le>o |B|" and LEQ: "\<forall>i \<in> I. |A i| \<le>o |B|"
-shows "|SIGMA i : I. A i| \<le>o |B|"
-proof(cases "I = {}", simp add: card_of_empty)
-  assume *: "I \<noteq> {}"
-  have "|SIGMA i : I. A i| \<le>o |I \<times> B|"
-  using LEQ card_of_Sigma_Times by blast
-  moreover have "|I \<times> B| =o |B|"
-  using INF * LEQ_I by (auto simp add: card_of_Times_infinite)
-  ultimately show ?thesis using ordLeq_ordIso_trans by blast
-qed
-
-
-lemma card_of_Sigma_ordLeq_infinite_Field:
-assumes INF: "\<not>finite (Field r)" and r: "Card_order r" and
-        LEQ_I: "|I| \<le>o r" and LEQ: "\<forall>i \<in> I. |A i| \<le>o r"
-shows "|SIGMA i : I. A i| \<le>o r"
-proof-
-  let ?B  = "Field r"
-  have 1: "r =o |?B| \<and> |?B| =o r" using r card_of_Field_ordIso
-  ordIso_symmetric by blast
-  hence "|I| \<le>o |?B|"  "\<forall>i \<in> I. |A i| \<le>o |?B|"
-  using LEQ_I LEQ ordLeq_ordIso_trans by blast+
-  hence  "|SIGMA i : I. A i| \<le>o |?B|" using INF LEQ
-  card_of_Sigma_ordLeq_infinite by blast
-  thus ?thesis using 1 ordLeq_ordIso_trans by blast
-qed
-
-
-lemma card_of_Times_ordLeq_infinite_Field:
-"\<lbrakk>\<not>finite (Field r); |A| \<le>o r; |B| \<le>o r; Card_order r\<rbrakk>
- \<Longrightarrow> |A <*> B| \<le>o r"
-by(simp add: card_of_Sigma_ordLeq_infinite_Field)
-
-
-lemma card_of_Times_infinite_simps:
-"\<lbrakk>\<not>finite A; B \<noteq> {}; |B| \<le>o |A|\<rbrakk> \<Longrightarrow> |A \<times> B| =o |A|"
-"\<lbrakk>\<not>finite A; B \<noteq> {}; |B| \<le>o |A|\<rbrakk> \<Longrightarrow> |A| =o |A \<times> B|"
-"\<lbrakk>\<not>finite A; B \<noteq> {}; |B| \<le>o |A|\<rbrakk> \<Longrightarrow> |B \<times> A| =o |A|"
-"\<lbrakk>\<not>finite A; B \<noteq> {}; |B| \<le>o |A|\<rbrakk> \<Longrightarrow> |A| =o |B \<times> A|"
-by (auto simp add: card_of_Times_infinite ordIso_symmetric)
-
-
-lemma card_of_UNION_ordLeq_infinite:
-assumes INF: "\<not>finite B" and
-        LEQ_I: "|I| \<le>o |B|" and LEQ: "\<forall>i \<in> I. |A i| \<le>o |B|"
-shows "|\<Union> i \<in> I. A i| \<le>o |B|"
-proof(cases "I = {}", simp add: card_of_empty)
-  assume *: "I \<noteq> {}"
-  have "|\<Union> i \<in> I. A i| \<le>o |SIGMA i : I. A i|"
-  using card_of_UNION_Sigma by blast
-  moreover have "|SIGMA i : I. A i| \<le>o |B|"
-  using assms card_of_Sigma_ordLeq_infinite by blast
-  ultimately show ?thesis using ordLeq_transitive by blast
-qed
-
-
-corollary card_of_UNION_ordLeq_infinite_Field:
-assumes INF: "\<not>finite (Field r)" and r: "Card_order r" and
-        LEQ_I: "|I| \<le>o r" and LEQ: "\<forall>i \<in> I. |A i| \<le>o r"
-shows "|\<Union> i \<in> I. A i| \<le>o r"
-proof-
-  let ?B  = "Field r"
-  have 1: "r =o |?B| \<and> |?B| =o r" using r card_of_Field_ordIso
-  ordIso_symmetric by blast
-  hence "|I| \<le>o |?B|"  "\<forall>i \<in> I. |A i| \<le>o |?B|"
-  using LEQ_I LEQ ordLeq_ordIso_trans by blast+
-  hence  "|\<Union> i \<in> I. A i| \<le>o |?B|" using INF LEQ
-  card_of_UNION_ordLeq_infinite by blast
-  thus ?thesis using 1 ordLeq_ordIso_trans by blast
-qed
-
-
-lemma card_of_Plus_infinite1:
-assumes INF: "\<not>finite A" and LEQ: "|B| \<le>o |A|"
-shows "|A <+> B| =o |A|"
-proof(cases "B = {}", simp add: card_of_Plus_empty1 card_of_Plus_empty2 ordIso_symmetric)
-  let ?Inl = "Inl::'a \<Rightarrow> 'a + 'b"  let ?Inr = "Inr::'b \<Rightarrow> 'a + 'b"
-  assume *: "B \<noteq> {}"
-  then obtain b1 where 1: "b1 \<in> B" by blast
-  show ?thesis
-  proof(cases "B = {b1}")
-    assume Case1: "B = {b1}"
-    have 2: "bij_betw ?Inl A ((?Inl ` A))"
-    unfolding bij_betw_def inj_on_def by auto
-    hence 3: "\<not>finite (?Inl ` A)"
-    using INF bij_betw_finite[of ?Inl A] by blast
-    let ?A' = "?Inl ` A \<union> {?Inr b1}"
-    obtain g where "bij_betw g (?Inl ` A) ?A'"
-    using 3 infinite_imp_bij_betw2[of "?Inl ` A"] by auto
-    moreover have "?A' = A <+> B" using Case1 by blast
-    ultimately have "bij_betw g (?Inl ` A) (A <+> B)" by simp
-    hence "bij_betw (g o ?Inl) A (A <+> B)"
-    using 2 by (auto simp add: bij_betw_trans)
-    thus ?thesis using card_of_ordIso ordIso_symmetric by blast
-  next
-    assume Case2: "B \<noteq> {b1}"
-    with * 1 obtain b2 where 3: "b1 \<noteq> b2 \<and> {b1,b2} \<le> B" by fastforce
-    obtain f where "inj_on f B \<and> f ` B \<le> A"
-    using LEQ card_of_ordLeq[of B] by fastforce
-    with 3 have "f b1 \<noteq> f b2 \<and> {f b1, f b2} \<le> A"
-    unfolding inj_on_def by auto
-    with 3 have "|A <+> B| \<le>o |A \<times> B|"
-    by (auto simp add: card_of_Plus_Times)
-    moreover have "|A \<times> B| =o |A|"
-    using assms * by (simp add: card_of_Times_infinite_simps)
-    ultimately have "|A <+> B| \<le>o |A|" using ordLeq_ordIso_trans by metis
-    thus ?thesis using card_of_Plus1 ordIso_iff_ordLeq by blast
-  qed
-qed
-
-
-lemma card_of_Plus_infinite2:
-assumes INF: "\<not>finite A" and LEQ: "|B| \<le>o |A|"
-shows "|B <+> A| =o |A|"
-using assms card_of_Plus_commute card_of_Plus_infinite1
-ordIso_equivalence by blast
-
-
-lemma card_of_Plus_infinite:
-assumes INF: "\<not>finite A" and LEQ: "|B| \<le>o |A|"
-shows "|A <+> B| =o |A| \<and> |B <+> A| =o |A|"
-using assms by (auto simp: card_of_Plus_infinite1 card_of_Plus_infinite2)
-
-
-corollary Card_order_Plus_infinite:
-assumes INF: "\<not>finite(Field r)" and CARD: "Card_order r" and
-        LEQ: "p \<le>o r"
-shows "| (Field r) <+> (Field p) | =o r \<and> | (Field p) <+> (Field r) | =o r"
-proof-
-  have "| Field r <+> Field p | =o | Field r | \<and>
-        | Field p <+> Field r | =o | Field r |"
-  using assms by (simp add: card_of_Plus_infinite card_of_mono2)
-  thus ?thesis
-  using assms card_of_Field_ordIso[of r]
-        ordIso_transitive[of "|Field r <+> Field p|"]
-        ordIso_transitive[of _ "|Field r|"] by blast
-qed
-
-
-subsection {* The cardinal $\omega$ and the finite cardinals  *}
-
-
-text{* The cardinal $\omega$, of natural numbers, shall be the standard non-strict
-order relation on
-@{text "nat"}, that we abbreviate by @{text "natLeq"}.  The finite cardinals
-shall be the restrictions of these relations to the numbers smaller than
-fixed numbers @{text "n"}, that we abbreviate by @{text "natLeq_on n"}.  *}
-
-abbreviation "(natLeq::(nat * nat) set) \<equiv> {(x,y). x \<le> y}"
-abbreviation "(natLess::(nat * nat) set) \<equiv> {(x,y). x < y}"
-
-abbreviation natLeq_on :: "nat \<Rightarrow> (nat * nat) set"
-where "natLeq_on n \<equiv> {(x,y). x < n \<and> y < n \<and> x \<le> y}"
-
-lemma infinite_cartesian_product:
-assumes "\<not>finite A" "\<not>finite B"
-shows "\<not>finite (A \<times> B)"
-proof
-  assume "finite (A \<times> B)"
-  from assms(1) have "A \<noteq> {}" by auto
-  with `finite (A \<times> B)` have "finite B" using finite_cartesian_productD2 by auto
-  with assms(2) show False by simp
-qed
-
-
-subsubsection {* First as well-orders *}
-
-
-lemma Field_natLeq: "Field natLeq = (UNIV::nat set)"
-by(unfold Field_def, auto)
-
-
-lemma natLeq_Refl: "Refl natLeq"
-unfolding refl_on_def Field_def by auto
-
-
-lemma natLeq_trans: "trans natLeq"
-unfolding trans_def by auto
-
-
-lemma natLeq_Preorder: "Preorder natLeq"
-unfolding preorder_on_def
-by (auto simp add: natLeq_Refl natLeq_trans)
-
-
-lemma natLeq_antisym: "antisym natLeq"
-unfolding antisym_def by auto
-
-
-lemma natLeq_Partial_order: "Partial_order natLeq"
-unfolding partial_order_on_def
-by (auto simp add: natLeq_Preorder natLeq_antisym)
-
-
-lemma natLeq_Total: "Total natLeq"
-unfolding total_on_def by auto
-
-
-lemma natLeq_Linear_order: "Linear_order natLeq"
-unfolding linear_order_on_def
-by (auto simp add: natLeq_Partial_order natLeq_Total)
-
-
-lemma natLeq_natLess_Id: "natLess = natLeq - Id"
-by auto
-
-
-lemma natLeq_Well_order: "Well_order natLeq"
-unfolding well_order_on_def
-using natLeq_Linear_order wf_less natLeq_natLess_Id by auto
-
-
-lemma Field_natLeq_on: "Field (natLeq_on n) = {x. x < n}"
-unfolding Field_def by auto
-
-
-lemma natLeq_underS_less: "underS natLeq n = {x. x < n}"
-unfolding underS_def by auto
-
-
-lemma Restr_natLeq: "Restr natLeq {x. x < n} = natLeq_on n"
-by force
-
-
-lemma Restr_natLeq2:
-"Restr natLeq (underS natLeq n) = natLeq_on n"
-by (auto simp add: Restr_natLeq natLeq_underS_less)
-
-
-lemma natLeq_on_Well_order: "Well_order(natLeq_on n)"
-using Restr_natLeq[of n] natLeq_Well_order
-      Well_order_Restr[of natLeq "{x. x < n}"] by auto
-
-
-corollary natLeq_on_well_order_on: "well_order_on {x. x < n} (natLeq_on n)"
-using natLeq_on_Well_order Field_natLeq_on by auto
-
-
-lemma natLeq_on_wo_rel: "wo_rel(natLeq_on n)"
-unfolding wo_rel_def using natLeq_on_Well_order .
-
-
-
-subsubsection {* Then as cardinals *}
-
-
-lemma natLeq_Card_order: "Card_order natLeq"
-proof(auto simp add: natLeq_Well_order
-      Card_order_iff_Restr_underS Restr_natLeq2, simp add:  Field_natLeq)
-  fix n have "finite(Field (natLeq_on n))" by (auto simp: Field_def)
-  moreover have "\<not>finite(UNIV::nat set)" by auto
-  ultimately show "natLeq_on n <o |UNIV::nat set|"
-  using finite_ordLess_infinite[of "natLeq_on n" "|UNIV::nat set|"]
-        Field_card_of[of "UNIV::nat set"]
-        card_of_Well_order[of "UNIV::nat set"] natLeq_on_Well_order[of n] by auto
-qed
-
-
-corollary card_of_Field_natLeq:
-"|Field natLeq| =o natLeq"
-using Field_natLeq natLeq_Card_order Card_order_iff_ordIso_card_of[of natLeq]
-      ordIso_symmetric[of natLeq] by blast
-
-
-corollary card_of_nat:
-"|UNIV::nat set| =o natLeq"
-using Field_natLeq card_of_Field_natLeq by auto
-
-
-corollary infinite_iff_natLeq_ordLeq:
-"\<not>finite A = ( natLeq \<le>o |A| )"
-using infinite_iff_card_of_nat[of A] card_of_nat
-      ordIso_ordLeq_trans ordLeq_ordIso_trans ordIso_symmetric by blast
-
-corollary finite_iff_ordLess_natLeq:
-"finite A = ( |A| <o natLeq)"
-using infinite_iff_natLeq_ordLeq not_ordLeq_iff_ordLess
-      card_of_Well_order natLeq_Well_order by metis
-
-
-subsection {* The successor of a cardinal *}
-
-
-text{* First we define @{text "isCardSuc r r'"}, the notion of @{text "r'"}
-being a successor cardinal of @{text "r"}. Although the definition does
-not require @{text "r"} to be a cardinal, only this case will be meaningful.  *}
-
-
-definition isCardSuc :: "'a rel \<Rightarrow> 'a set rel \<Rightarrow> bool"
-where
-"isCardSuc r r' \<equiv>
- Card_order r' \<and> r <o r' \<and>
- (\<forall>(r''::'a set rel). Card_order r'' \<and> r <o r'' \<longrightarrow> r' \<le>o r'')"
-
-
-text{* Now we introduce the cardinal-successor operator @{text "cardSuc"},
-by picking {\em some} cardinal-order relation fulfilling @{text "isCardSuc"}.
-Again, the picked item shall be proved unique up to order-isomorphism. *}
-
-
-definition cardSuc :: "'a rel \<Rightarrow> 'a set rel"
-where
-"cardSuc r \<equiv> SOME r'. isCardSuc r r'"
-
-
-lemma exists_minim_Card_order:
-"\<lbrakk>R \<noteq> {}; \<forall>r \<in> R. Card_order r\<rbrakk> \<Longrightarrow> \<exists>r \<in> R. \<forall>r' \<in> R. r \<le>o r'"
-unfolding card_order_on_def using exists_minim_Well_order by blast
-
-
-lemma exists_isCardSuc:
-assumes "Card_order r"
-shows "\<exists>r'. isCardSuc r r'"
-proof-
-  let ?R = "{(r'::'a set rel). Card_order r' \<and> r <o r'}"
-  have "|Pow(Field r)| \<in> ?R \<and> (\<forall>r \<in> ?R. Card_order r)" using assms
-  by (simp add: card_of_Card_order Card_order_Pow)
-  then obtain r where "r \<in> ?R \<and> (\<forall>r' \<in> ?R. r \<le>o r')"
-  using exists_minim_Card_order[of ?R] by blast
-  thus ?thesis unfolding isCardSuc_def by auto
-qed
-
-
-lemma cardSuc_isCardSuc:
-assumes "Card_order r"
-shows "isCardSuc r (cardSuc r)"
-unfolding cardSuc_def using assms
-by (simp add: exists_isCardSuc someI_ex)
-
-
-lemma cardSuc_Card_order:
-"Card_order r \<Longrightarrow> Card_order(cardSuc r)"
-using cardSuc_isCardSuc unfolding isCardSuc_def by blast
-
-
-lemma cardSuc_greater:
-"Card_order r \<Longrightarrow> r <o cardSuc r"
-using cardSuc_isCardSuc unfolding isCardSuc_def by blast
-
-
-lemma cardSuc_ordLeq:
-"Card_order r \<Longrightarrow> r \<le>o cardSuc r"
-using cardSuc_greater ordLeq_iff_ordLess_or_ordIso by blast
-
-
-text{* The minimality property of @{text "cardSuc"} originally present in its definition
-is local to the type @{text "'a set rel"}, i.e., that of @{text "cardSuc r"}:  *}
-
-lemma cardSuc_least_aux:
-"\<lbrakk>Card_order (r::'a rel); Card_order (r'::'a set rel); r <o r'\<rbrakk> \<Longrightarrow> cardSuc r \<le>o r'"
-using cardSuc_isCardSuc unfolding isCardSuc_def by blast
-
-
-text{* But from this we can infer general minimality: *}
-
-lemma cardSuc_least:
-assumes CARD: "Card_order r" and CARD': "Card_order r'" and LESS: "r <o r'"
-shows "cardSuc r \<le>o r'"
-proof-
-  let ?p = "cardSuc r"
-  have 0: "Well_order ?p \<and> Well_order r'"
-  using assms cardSuc_Card_order unfolding card_order_on_def by blast
-  {assume "r' <o ?p"
-   then obtain r'' where 1: "Field r'' < Field ?p" and 2: "r' =o r'' \<and> r'' <o ?p"
-   using internalize_ordLess[of r' ?p] by blast
-   (*  *)
-   have "Card_order r''" using CARD' Card_order_ordIso2 2 by blast
-   moreover have "r <o r''" using LESS 2 ordLess_ordIso_trans by blast
-   ultimately have "?p \<le>o r''" using cardSuc_least_aux CARD by blast
-   hence False using 2 not_ordLess_ordLeq by blast
-  }
-  thus ?thesis using 0 ordLess_or_ordLeq by blast
-qed
-
-
-lemma cardSuc_ordLess_ordLeq:
-assumes CARD: "Card_order r" and CARD': "Card_order r'"
-shows "(r <o r') = (cardSuc r \<le>o r')"
-proof(auto simp add: assms cardSuc_least)
-  assume "cardSuc r \<le>o r'"
-  thus "r <o r'" using assms cardSuc_greater ordLess_ordLeq_trans by blast
-qed
-
-
-lemma cardSuc_ordLeq_ordLess:
-assumes CARD: "Card_order r" and CARD': "Card_order r'"
-shows "(r' <o cardSuc r) = (r' \<le>o r)"
-proof-
-  have "Well_order r \<and> Well_order r'"
-  using assms unfolding card_order_on_def by auto
-  moreover have "Well_order(cardSuc r)"
-  using assms cardSuc_Card_order card_order_on_def by blast
-  ultimately show ?thesis
-  using assms cardSuc_ordLess_ordLeq[of r r']
-  not_ordLeq_iff_ordLess[of r r'] not_ordLeq_iff_ordLess[of r' "cardSuc r"] by blast
-qed
-
-
-lemma cardSuc_mono_ordLeq:
-assumes CARD: "Card_order r" and CARD': "Card_order r'"
-shows "(cardSuc r \<le>o cardSuc r') = (r \<le>o r')"
-using assms cardSuc_ordLeq_ordLess cardSuc_ordLess_ordLeq cardSuc_Card_order by blast
-
-
-lemma cardSuc_invar_ordIso:
-assumes CARD: "Card_order r" and CARD': "Card_order r'"
-shows "(cardSuc r =o cardSuc r') = (r =o r')"
-proof-
-  have 0: "Well_order r \<and> Well_order r' \<and> Well_order(cardSuc r) \<and> Well_order(cardSuc r')"
-  using assms by (simp add: card_order_on_well_order_on cardSuc_Card_order)
-  thus ?thesis
-  using ordIso_iff_ordLeq[of r r'] ordIso_iff_ordLeq
-  using cardSuc_mono_ordLeq[of r r'] cardSuc_mono_ordLeq[of r' r] assms by blast
-qed
-
-
-lemma card_of_cardSuc_finite:
-"finite(Field(cardSuc |A| )) = finite A"
-proof
-  assume *: "finite (Field (cardSuc |A| ))"
-  have 0: "|Field(cardSuc |A| )| =o cardSuc |A|"
-  using card_of_Card_order cardSuc_Card_order card_of_Field_ordIso by blast
-  hence "|A| \<le>o |Field(cardSuc |A| )|"
-  using card_of_Card_order[of A] cardSuc_ordLeq[of "|A|"] ordIso_symmetric
-  ordLeq_ordIso_trans by blast
-  thus "finite A" using * card_of_ordLeq_finite by blast
-next
-  assume "finite A"
-  then have "finite ( Field |Pow A| )" unfolding Field_card_of by simp
-  then show "finite (Field (cardSuc |A| ))"
-  proof (rule card_of_ordLeq_finite[OF card_of_mono2, rotated])
-    show "cardSuc |A| \<le>o |Pow A|"
-      by (metis cardSuc_ordLess_ordLeq card_of_Card_order card_of_Pow)
-  qed
-qed
-
-
-lemma cardSuc_finite:
-assumes "Card_order r"
-shows "finite (Field (cardSuc r)) = finite (Field r)"
-proof-
-  let ?A = "Field r"
-  have "|?A| =o r" using assms by (simp add: card_of_Field_ordIso)
-  hence "cardSuc |?A| =o cardSuc r" using assms
-  by (simp add: card_of_Card_order cardSuc_invar_ordIso)
-  moreover have "|Field (cardSuc |?A| ) | =o cardSuc |?A|"
-  by (simp add: card_of_card_order_on Field_card_of card_of_Field_ordIso cardSuc_Card_order)
-  moreover
-  {have "|Field (cardSuc r) | =o cardSuc r"
-   using assms by (simp add: card_of_Field_ordIso cardSuc_Card_order)
-   hence "cardSuc r =o |Field (cardSuc r) |"
-   using ordIso_symmetric by blast
-  }
-  ultimately have "|Field (cardSuc |?A| ) | =o |Field (cardSuc r) |"
-  using ordIso_transitive by blast
-  hence "finite (Field (cardSuc |?A| )) = finite (Field (cardSuc r))"
-  using card_of_ordIso_finite by blast
-  thus ?thesis by (simp only: card_of_cardSuc_finite)
-qed
-
-
-lemma card_of_Plus_ordLess_infinite:
-assumes INF: "\<not>finite C" and
-        LESS1: "|A| <o |C|" and LESS2: "|B| <o |C|"
-shows "|A <+> B| <o |C|"
-proof(cases "A = {} \<or> B = {}")
-  assume Case1: "A = {} \<or> B = {}"
-  hence "|A| =o |A <+> B| \<or> |B| =o |A <+> B|"
-  using card_of_Plus_empty1 card_of_Plus_empty2 by blast
-  hence "|A <+> B| =o |A| \<or> |A <+> B| =o |B|"
-  using ordIso_symmetric[of "|A|"] ordIso_symmetric[of "|B|"] by blast
-  thus ?thesis using LESS1 LESS2
-       ordIso_ordLess_trans[of "|A <+> B|" "|A|"]
-       ordIso_ordLess_trans[of "|A <+> B|" "|B|"] by blast
-next
-  assume Case2: "\<not>(A = {} \<or> B = {})"
-  {assume *: "|C| \<le>o |A <+> B|"
-   hence "\<not>finite (A <+> B)" using INF card_of_ordLeq_finite by blast
-   hence 1: "\<not>finite A \<or> \<not>finite B" using finite_Plus by blast
-   {assume Case21: "|A| \<le>o |B|"
-    hence "\<not>finite B" using 1 card_of_ordLeq_finite by blast
-    hence "|A <+> B| =o |B|" using Case2 Case21
-    by (auto simp add: card_of_Plus_infinite)
-    hence False using LESS2 not_ordLess_ordLeq * ordLeq_ordIso_trans by blast
-   }
-   moreover
-   {assume Case22: "|B| \<le>o |A|"
-    hence "\<not>finite A" using 1 card_of_ordLeq_finite by blast
-    hence "|A <+> B| =o |A|" using Case2 Case22
-    by (auto simp add: card_of_Plus_infinite)
-    hence False using LESS1 not_ordLess_ordLeq * ordLeq_ordIso_trans by blast
-   }
-   ultimately have False using ordLeq_total card_of_Well_order[of A]
-   card_of_Well_order[of B] by blast
-  }
-  thus ?thesis using ordLess_or_ordLeq[of "|A <+> B|" "|C|"]
-  card_of_Well_order[of "A <+> B"] card_of_Well_order[of "C"] by auto
-qed
-
-
-lemma card_of_Plus_ordLess_infinite_Field:
-assumes INF: "\<not>finite (Field r)" and r: "Card_order r" and
-        LESS1: "|A| <o r" and LESS2: "|B| <o r"
-shows "|A <+> B| <o r"
-proof-
-  let ?C  = "Field r"
-  have 1: "r =o |?C| \<and> |?C| =o r" using r card_of_Field_ordIso
-  ordIso_symmetric by blast
-  hence "|A| <o |?C|"  "|B| <o |?C|"
-  using LESS1 LESS2 ordLess_ordIso_trans by blast+
-  hence  "|A <+> B| <o |?C|" using INF
-  card_of_Plus_ordLess_infinite by blast
-  thus ?thesis using 1 ordLess_ordIso_trans by blast
-qed
-
-
-lemma card_of_Plus_ordLeq_infinite_Field:
-assumes r: "\<not>finite (Field r)" and A: "|A| \<le>o r" and B: "|B| \<le>o r"
-and c: "Card_order r"
-shows "|A <+> B| \<le>o r"
-proof-
-  let ?r' = "cardSuc r"
-  have "Card_order ?r' \<and> \<not>finite (Field ?r')" using assms
-  by (simp add: cardSuc_Card_order cardSuc_finite)
-  moreover have "|A| <o ?r'" and "|B| <o ?r'" using A B c
-  by (auto simp: card_of_card_order_on Field_card_of cardSuc_ordLeq_ordLess)
-  ultimately have "|A <+> B| <o ?r'"
-  using card_of_Plus_ordLess_infinite_Field by blast
-  thus ?thesis using c r
-  by (simp add: card_of_card_order_on Field_card_of cardSuc_ordLeq_ordLess)
-qed
-
-
-lemma card_of_Un_ordLeq_infinite_Field:
-assumes C: "\<not>finite (Field r)" and A: "|A| \<le>o r" and B: "|B| \<le>o r"
-and "Card_order r"
-shows "|A Un B| \<le>o r"
-using assms card_of_Plus_ordLeq_infinite_Field card_of_Un_Plus_ordLeq
-ordLeq_transitive by fast
-
-
-
-subsection {* Regular cardinals *}
-
-
-definition cofinal where
-"cofinal A r \<equiv>
- ALL a : Field r. EX b : A. a \<noteq> b \<and> (a,b) : r"
-
-
-definition regular where
-"regular r \<equiv>
- ALL K. K \<le> Field r \<and> cofinal K r \<longrightarrow> |K| =o r"
-
-
-definition relChain where
-"relChain r As \<equiv>
- ALL i j. (i,j) \<in> r \<longrightarrow> As i \<le> As j"
-
-lemma regular_UNION:
-assumes r: "Card_order r"   "regular r"
-and As: "relChain r As"
-and Bsub: "B \<le> (UN i : Field r. As i)"
-and cardB: "|B| <o r"
-shows "EX i : Field r. B \<le> As i"
-proof-
-  let ?phi = "%b j. j : Field r \<and> b : As j"
-  have "ALL b : B. EX j. ?phi b j" using Bsub by blast
-  then obtain f where f: "!! b. b : B \<Longrightarrow> ?phi b (f b)"
-  using bchoice[of B ?phi] by blast
-  let ?K = "f ` B"
-  {assume 1: "!! i. i : Field r \<Longrightarrow> ~ B \<le> As i"
-   have 2: "cofinal ?K r"
-   unfolding cofinal_def proof auto
-     fix i assume i: "i : Field r"
-     with 1 obtain b where b: "b : B \<and> b \<notin> As i" by blast
-     hence "i \<noteq> f b \<and> ~ (f b,i) : r"
-     using As f unfolding relChain_def by auto
-     hence "i \<noteq> f b \<and> (i, f b) : r" using r
-     unfolding card_order_on_def well_order_on_def linear_order_on_def
-     total_on_def using i f b by auto
-     with b show "\<exists>b\<in>B. i \<noteq> f b \<and> (i, f b) \<in> r" by blast
-   qed
-   moreover have "?K \<le> Field r" using f by blast
-   ultimately have "|?K| =o r" using 2 r unfolding regular_def by blast
-   moreover
-   {
-    have "|?K| <=o |B|" using card_of_image .
-    hence "|?K| <o r" using cardB ordLeq_ordLess_trans by blast
-   }
-   ultimately have False using not_ordLess_ordIso by blast
-  }
-  thus ?thesis by blast
-qed
-
-
-lemma infinite_cardSuc_regular:
-assumes r_inf: "\<not>finite (Field r)" and r_card: "Card_order r"
-shows "regular (cardSuc r)"
-proof-
-  let ?r' = "cardSuc r"
-  have r': "Card_order ?r'"
-  "!! p. Card_order p \<longrightarrow> (p \<le>o r) = (p <o ?r')"
-  using r_card by (auto simp: cardSuc_Card_order cardSuc_ordLeq_ordLess)
-  show ?thesis
-  unfolding regular_def proof auto
-    fix K assume 1: "K \<le> Field ?r'" and 2: "cofinal K ?r'"
-    hence "|K| \<le>o |Field ?r'|" by (simp only: card_of_mono1)
-    also have 22: "|Field ?r'| =o ?r'"
-    using r' by (simp add: card_of_Field_ordIso[of ?r'])
-    finally have "|K| \<le>o ?r'" .
-    moreover
-    {let ?L = "UN j : K. underS ?r' j"
-     let ?J = "Field r"
-     have rJ: "r =o |?J|"
-     using r_card card_of_Field_ordIso ordIso_symmetric by blast
-     assume "|K| <o ?r'"
-     hence "|K| <=o r" using r' card_of_Card_order[of K] by blast
-     hence "|K| \<le>o |?J|" using rJ ordLeq_ordIso_trans by blast
-     moreover
-     {have "ALL j : K. |underS ?r' j| <o ?r'"
-      using r' 1 by (auto simp: card_of_underS)
-      hence "ALL j : K. |underS ?r' j| \<le>o r"
-      using r' card_of_Card_order by blast
-      hence "ALL j : K. |underS ?r' j| \<le>o |?J|"
-      using rJ ordLeq_ordIso_trans by blast
-     }
-     ultimately have "|?L| \<le>o |?J|"
-     using r_inf card_of_UNION_ordLeq_infinite by blast
-     hence "|?L| \<le>o r" using rJ ordIso_symmetric ordLeq_ordIso_trans by blast
-     hence "|?L| <o ?r'" using r' card_of_Card_order by blast
-     moreover
-     {
-      have "Field ?r' \<le> ?L"
-      using 2 unfolding underS_def cofinal_def by auto
-      hence "|Field ?r'| \<le>o |?L|" by (simp add: card_of_mono1)
-      hence "?r' \<le>o |?L|"
-      using 22 ordIso_ordLeq_trans ordIso_symmetric by blast
-     }
-     ultimately have "|?L| <o |?L|" using ordLess_ordLeq_trans by blast
-     hence False using ordLess_irreflexive by blast
-    }
-    ultimately show "|K| =o ?r'"
-    unfolding ordLeq_iff_ordLess_or_ordIso by blast
-  qed
-qed
-
-lemma cardSuc_UNION:
-assumes r: "Card_order r" and "\<not>finite (Field r)"
-and As: "relChain (cardSuc r) As"
-and Bsub: "B \<le> (UN i : Field (cardSuc r). As i)"
-and cardB: "|B| <=o r"
-shows "EX i : Field (cardSuc r). B \<le> As i"
-proof-
-  let ?r' = "cardSuc r"
-  have "Card_order ?r' \<and> |B| <o ?r'"
-  using r cardB cardSuc_ordLeq_ordLess cardSuc_Card_order
-  card_of_Card_order by blast
-  moreover have "regular ?r'"
-  using assms by(simp add: infinite_cardSuc_regular)
-  ultimately show ?thesis
-  using As Bsub cardB regular_UNION by blast
-qed
-
-
-subsection {* Others *}
-
-lemma card_of_Func_Times:
-"|Func (A <*> B) C| =o |Func A (Func B C)|"
-unfolding card_of_ordIso[symmetric]
-using bij_betw_curr by blast
-
-lemma card_of_Pow_Func:
-"|Pow A| =o |Func A (UNIV::bool set)|"
-proof-
-  def F \<equiv> "\<lambda> A' a. if a \<in> A then (if a \<in> A' then True else False)
-                            else undefined"
-  have "bij_betw F (Pow A) (Func A (UNIV::bool set))"
-  unfolding bij_betw_def inj_on_def proof (intro ballI impI conjI)
-    fix A1 A2 assume "A1 \<in> Pow A" "A2 \<in> Pow A" "F A1 = F A2"
-    thus "A1 = A2" unfolding F_def Pow_def fun_eq_iff by (auto split: split_if_asm)
-  next
-    show "F ` Pow A = Func A UNIV"
-    proof safe
-      fix f assume f: "f \<in> Func A (UNIV::bool set)"
-      show "f \<in> F ` Pow A" unfolding image_def mem_Collect_eq proof(intro bexI)
-        let ?A1 = "{a \<in> A. f a = True}"
-        show "f = F ?A1" unfolding F_def apply(rule ext)
-        using f unfolding Func_def mem_Collect_eq by auto
-      qed auto
-    qed(unfold Func_def mem_Collect_eq F_def, auto)
-  qed
-  thus ?thesis unfolding card_of_ordIso[symmetric] by blast
-qed
-
-lemma card_of_Func_UNIV:
-"|Func (UNIV::'a set) (B::'b set)| =o |{f::'a \<Rightarrow> 'b. range f \<subseteq> B}|"
-apply(rule ordIso_symmetric) proof(intro card_of_ordIsoI)
-  let ?F = "\<lambda> f (a::'a). ((f a)::'b)"
-  show "bij_betw ?F {f. range f \<subseteq> B} (Func UNIV B)"
-  unfolding bij_betw_def inj_on_def proof safe
-    fix h :: "'a \<Rightarrow> 'b" assume h: "h \<in> Func UNIV B"
-    hence "\<forall> a. \<exists> b. h a = b" unfolding Func_def by auto
-    then obtain f where f: "\<forall> a. h a = f a" by metis
-    hence "range f \<subseteq> B" using h unfolding Func_def by auto
-    thus "h \<in> (\<lambda>f a. f a) ` {f. range f \<subseteq> B}" using f unfolding image_def by auto
-  qed(unfold Func_def fun_eq_iff, auto)
-qed
-
-end
--- a/src/HOL/Cardinals/Constructions_on_Wellorders_FP.thy	Mon Jan 20 16:14:19 2014 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1774 +0,0 @@
-(*  Title:      HOL/Cardinals/Constructions_on_Wellorders_FP.thy
-    Author:     Andrei Popescu, TU Muenchen
-    Copyright   2012
-
-Constructions on wellorders (FP).
-*)
-
-header {* Constructions on Wellorders (FP) *}
-
-theory Constructions_on_Wellorders_FP
-imports Wellorder_Embedding_FP
-begin
-
-
-text {* In this section, we study basic constructions on well-orders, such as restriction to
-a set/order filter, copy via direct images, ordinal-like sum of disjoint well-orders,
-and bounded square.  We also define between well-orders
-the relations @{text "ordLeq"}, of being embedded (abbreviated @{text "\<le>o"}),
-@{text "ordLess"}, of being strictly embedded (abbreviated @{text "<o"}), and
-@{text "ordIso"}, of being isomorphic (abbreviated @{text "=o"}).  We study the
-connections between these relations, order filters, and the aforementioned constructions.
-A main result of this section is that @{text "<o"} is well-founded.  *}
-
-
-subsection {* Restriction to a set  *}
-
-
-abbreviation Restr :: "'a rel \<Rightarrow> 'a set \<Rightarrow> 'a rel"
-where "Restr r A \<equiv> r Int (A \<times> A)"
-
-
-lemma Restr_subset:
-"A \<le> B \<Longrightarrow> Restr (Restr r B) A = Restr r A"
-by blast
-
-
-lemma Restr_Field: "Restr r (Field r) = r"
-unfolding Field_def by auto
-
-
-lemma Refl_Restr: "Refl r \<Longrightarrow> Refl(Restr r A)"
-unfolding refl_on_def Field_def by auto
-
-
-lemma antisym_Restr:
-"antisym r \<Longrightarrow> antisym(Restr r A)"
-unfolding antisym_def Field_def by auto
-
-
-lemma Total_Restr:
-"Total r \<Longrightarrow> Total(Restr r A)"
-unfolding total_on_def Field_def by auto
-
-
-lemma trans_Restr:
-"trans r \<Longrightarrow> trans(Restr r A)"
-unfolding trans_def Field_def by blast
-
-
-lemma Preorder_Restr:
-"Preorder r \<Longrightarrow> Preorder(Restr r A)"
-unfolding preorder_on_def by (simp add: Refl_Restr trans_Restr)
-
-
-lemma Partial_order_Restr:
-"Partial_order r \<Longrightarrow> Partial_order(Restr r A)"
-unfolding partial_order_on_def by (simp add: Preorder_Restr antisym_Restr)
-
-
-lemma Linear_order_Restr:
-"Linear_order r \<Longrightarrow> Linear_order(Restr r A)"
-unfolding linear_order_on_def by (simp add: Partial_order_Restr Total_Restr)
-
-
-lemma Well_order_Restr:
-assumes "Well_order r"
-shows "Well_order(Restr r A)"
-proof-
-  have "Restr r A - Id \<le> r - Id" using Restr_subset by blast
-  hence "wf(Restr r A - Id)" using assms
-  using well_order_on_def wf_subset by blast
-  thus ?thesis using assms unfolding well_order_on_def
-  by (simp add: Linear_order_Restr)
-qed
-
-
-lemma Field_Restr_subset: "Field(Restr r A) \<le> A"
-by (auto simp add: Field_def)
-
-
-lemma Refl_Field_Restr:
-"Refl r \<Longrightarrow> Field(Restr r A) = (Field r) Int A"
-unfolding refl_on_def Field_def by blast
-
-
-lemma Refl_Field_Restr2:
-"\<lbrakk>Refl r; A \<le> Field r\<rbrakk> \<Longrightarrow> Field(Restr r A) = A"
-by (auto simp add: Refl_Field_Restr)
-
-
-lemma well_order_on_Restr:
-assumes WELL: "Well_order r" and SUB: "A \<le> Field r"
-shows "well_order_on A (Restr r A)"
-using assms
-using Well_order_Restr[of r A] Refl_Field_Restr2[of r A]
-     order_on_defs[of "Field r" r] by auto
-
-
-subsection {* Order filters versus restrictions and embeddings  *}
-
-
-lemma Field_Restr_ofilter:
-"\<lbrakk>Well_order r; wo_rel.ofilter r A\<rbrakk> \<Longrightarrow> Field(Restr r A) = A"
-by (auto simp add: wo_rel_def wo_rel.ofilter_def wo_rel.REFL Refl_Field_Restr2)
-
-
-lemma ofilter_Restr_under:
-assumes WELL: "Well_order r" and OF: "wo_rel.ofilter r A" and IN: "a \<in> A"
-shows "under (Restr r A) a = under r a"
-using assms wo_rel_def
-proof(auto simp add: wo_rel.ofilter_def under_def)
-  fix b assume *: "a \<in> A" and "(b,a) \<in> r"
-  hence "b \<in> under r a \<and> a \<in> Field r"
-  unfolding under_def using Field_def by fastforce
-  thus "b \<in> A" using * assms by (auto simp add: wo_rel_def wo_rel.ofilter_def)
-qed
-
-
-lemma ofilter_embed:
-assumes "Well_order r"
-shows "wo_rel.ofilter r A = (A \<le> Field r \<and> embed (Restr r A) r id)"
-proof
-  assume *: "wo_rel.ofilter r A"
-  show "A \<le> Field r \<and> embed (Restr r A) r id"
-  proof(unfold embed_def, auto)
-    fix a assume "a \<in> A" thus "a \<in> Field r" using assms *
-    by (auto simp add: wo_rel_def wo_rel.ofilter_def)
-  next
-    fix a assume "a \<in> Field (Restr r A)"
-    thus "bij_betw id (under (Restr r A) a) (under r a)" using assms *
-    by (simp add: ofilter_Restr_under Field_Restr_ofilter)
-  qed
-next
-  assume *: "A \<le> Field r \<and> embed (Restr r A) r id"
-  hence "Field(Restr r A) \<le> Field r"
-  using assms  embed_Field[of "Restr r A" r id] id_def
-        Well_order_Restr[of r] by auto
-  {fix a assume "a \<in> A"
-   hence "a \<in> Field(Restr r A)" using * assms
-   by (simp add: order_on_defs Refl_Field_Restr2)
-   hence "bij_betw id (under (Restr r A) a) (under r a)"
-   using * unfolding embed_def by auto
-   hence "under r a \<le> under (Restr r A) a"
-   unfolding bij_betw_def by auto
-   also have "\<dots> \<le> Field(Restr r A)" by (simp add: under_Field)
-   also have "\<dots> \<le> A" by (simp add: Field_Restr_subset)
-   finally have "under r a \<le> A" .
-  }
-  thus "wo_rel.ofilter r A" using assms * by (simp add: wo_rel_def wo_rel.ofilter_def)
-qed
-
-
-lemma ofilter_Restr_Int:
-assumes WELL: "Well_order r" and OFA: "wo_rel.ofilter r A"
-shows "wo_rel.ofilter (Restr r B) (A Int B)"
-proof-
-  let ?rB = "Restr r B"
-  have Well: "wo_rel r" unfolding wo_rel_def using WELL .
-  hence Refl: "Refl r" by (simp add: wo_rel.REFL)
-  hence Field: "Field ?rB = Field r Int B"
-  using Refl_Field_Restr by blast
-  have WellB: "wo_rel ?rB \<and> Well_order ?rB" using WELL
-  by (simp add: Well_order_Restr wo_rel_def)
-  (* Main proof *)
-  show ?thesis using WellB assms
-  proof(auto simp add: wo_rel.ofilter_def under_def)
-    fix a assume "a \<in> A" and *: "a \<in> B"
-    hence "a \<in> Field r" using OFA Well by (auto simp add: wo_rel.ofilter_def)
-    with * show "a \<in> Field ?rB" using Field by auto
-  next
-    fix a b assume "a \<in> A" and "(b,a) \<in> r"
-    thus "b \<in> A" using Well OFA by (auto simp add: wo_rel.ofilter_def under_def)
-  qed
-qed
-
-
-lemma ofilter_Restr_subset:
-assumes WELL: "Well_order r" and OFA: "wo_rel.ofilter r A" and SUB: "A \<le> B"
-shows "wo_rel.ofilter (Restr r B) A"
-proof-
-  have "A Int B = A" using SUB by blast
-  thus ?thesis using assms ofilter_Restr_Int[of r A B] by auto
-qed
-
-
-lemma ofilter_subset_embed:
-assumes WELL: "Well_order r" and
-        OFA: "wo_rel.ofilter r A" and OFB: "wo_rel.ofilter r B"
-shows "(A \<le> B) = (embed (Restr r A) (Restr r B) id)"
-proof-
-  let ?rA = "Restr r A"  let ?rB = "Restr r B"
-  have Well: "wo_rel r" unfolding wo_rel_def using WELL .
-  hence Refl: "Refl r" by (simp add: wo_rel.REFL)
-  hence FieldA: "Field ?rA = Field r Int A"
-  using Refl_Field_Restr by blast
-  have FieldB: "Field ?rB = Field r Int B"
-  using Refl Refl_Field_Restr by blast
-  have WellA: "wo_rel ?rA \<and> Well_order ?rA" using WELL
-  by (simp add: Well_order_Restr wo_rel_def)
-  have WellB: "wo_rel ?rB \<and> Well_order ?rB" using WELL
-  by (simp add: Well_order_Restr wo_rel_def)
-  (* Main proof *)
-  show ?thesis
-  proof
-    assume *: "A \<le> B"
-    hence "wo_rel.ofilter (Restr r B) A" using assms
-    by (simp add: ofilter_Restr_subset)
-    hence "embed (Restr ?rB A) (Restr r B) id"
-    using WellB ofilter_embed[of "?rB" A] by auto
-    thus "embed (Restr r A) (Restr r B) id"
-    using * by (simp add: Restr_subset)
-  next
-    assume *: "embed (Restr r A) (Restr r B) id"
-    {fix a assume **: "a \<in> A"
-     hence "a \<in> Field r" using Well OFA by (auto simp add: wo_rel.ofilter_def)
-     with ** FieldA have "a \<in> Field ?rA" by auto
-     hence "a \<in> Field ?rB" using * WellA embed_Field[of ?rA ?rB id] by auto
-     hence "a \<in> B" using FieldB by auto
-    }
-    thus "A \<le> B" by blast
-  qed
-qed
-
-
-lemma ofilter_subset_embedS_iso:
-assumes WELL: "Well_order r" and
-        OFA: "wo_rel.ofilter r A" and OFB: "wo_rel.ofilter r B"
-shows "((A < B) = (embedS (Restr r A) (Restr r B) id)) \<and>
-       ((A = B) = (iso (Restr r A) (Restr r B) id))"
-proof-
-  let ?rA = "Restr r A"  let ?rB = "Restr r B"
-  have Well: "wo_rel r" unfolding wo_rel_def using WELL .
-  hence Refl: "Refl r" by (simp add: wo_rel.REFL)
-  hence "Field ?rA = Field r Int A"
-  using Refl_Field_Restr by blast
-  hence FieldA: "Field ?rA = A" using OFA Well
-  by (auto simp add: wo_rel.ofilter_def)
-  have "Field ?rB = Field r Int B"
-  using Refl Refl_Field_Restr by blast
-  hence FieldB: "Field ?rB = B" using OFB Well
-  by (auto simp add: wo_rel.ofilter_def)
-  (* Main proof *)
-  show ?thesis unfolding embedS_def iso_def
-  using assms ofilter_subset_embed[of r A B]
-        FieldA FieldB bij_betw_id_iff[of A B] by auto
-qed
-
-
-lemma ofilter_subset_embedS:
-assumes WELL: "Well_order r" and
-        OFA: "wo_rel.ofilter r A" and OFB: "wo_rel.ofilter r B"
-shows "(A < B) = embedS (Restr r A) (Restr r B) id"
-using assms by (simp add: ofilter_subset_embedS_iso)
-
-
-lemma embed_implies_iso_Restr:
-assumes WELL: "Well_order r" and WELL': "Well_order r'" and
-        EMB: "embed r' r f"
-shows "iso r' (Restr r (f ` (Field r'))) f"
-proof-
-  let ?A' = "Field r'"
-  let ?r'' = "Restr r (f ` ?A')"
-  have 0: "Well_order ?r''" using WELL Well_order_Restr by blast
-  have 1: "wo_rel.ofilter r (f ` ?A')" using assms embed_Field_ofilter  by blast
-  hence "Field ?r'' = f ` (Field r')" using WELL Field_Restr_ofilter by blast
-  hence "bij_betw f ?A' (Field ?r'')"
-  using EMB embed_inj_on WELL' unfolding bij_betw_def by blast
-  moreover
-  {have "\<forall>a b. (a,b) \<in> r' \<longrightarrow> a \<in> Field r' \<and> b \<in> Field r'"
-   unfolding Field_def by auto
-   hence "compat r' ?r'' f"
-   using assms embed_iff_compat_inj_on_ofilter
-   unfolding compat_def by blast
-  }
-  ultimately show ?thesis using WELL' 0 iso_iff3 by blast
-qed
-
-
-subsection {* The strict inclusion on proper ofilters is well-founded *}
-
-
-definition ofilterIncl :: "'a rel \<Rightarrow> 'a set rel"
-where
-"ofilterIncl r \<equiv> {(A,B). wo_rel.ofilter r A \<and> A \<noteq> Field r \<and>
-                         wo_rel.ofilter r B \<and> B \<noteq> Field r \<and> A < B}"
-
-
-lemma wf_ofilterIncl:
-assumes WELL: "Well_order r"
-shows "wf(ofilterIncl r)"
-proof-
-  have Well: "wo_rel r" using WELL by (simp add: wo_rel_def)
-  hence Lo: "Linear_order r" by (simp add: wo_rel.LIN)
-  let ?h = "(\<lambda> A. wo_rel.suc r A)"
-  let ?rS = "r - Id"
-  have "wf ?rS" using WELL by (simp add: order_on_defs)
-  moreover
-  have "compat (ofilterIncl r) ?rS ?h"
-  proof(unfold compat_def ofilterIncl_def,
-        intro allI impI, simp, elim conjE)
-    fix A B
-    assume *: "wo_rel.ofilter r A" "A \<noteq> Field r" and
-           **: "wo_rel.ofilter r B" "B \<noteq> Field r" and ***: "A < B"
-    then obtain a and b where 0: "a \<in> Field r \<and> b \<in> Field r" and
-                         1: "A = underS r a \<and> B = underS r b"
-    using Well by (auto simp add: wo_rel.ofilter_underS_Field)
-    hence "a \<noteq> b" using *** by auto
-    moreover
-    have "(a,b) \<in> r" using 0 1 Lo ***
-    by (auto simp add: underS_incl_iff)
-    moreover
-    have "a = wo_rel.suc r A \<and> b = wo_rel.suc r B"
-    using Well 0 1 by (simp add: wo_rel.suc_underS)
-    ultimately
-    show "(wo_rel.suc r A, wo_rel.suc r B) \<in> r \<and> wo_rel.suc r A \<noteq> wo_rel.suc r B"
-    by simp
-  qed
-  ultimately show "wf (ofilterIncl r)" by (simp add: compat_wf)
-qed
-
-
-
-subsection {* Ordering the well-orders by existence of embeddings *}
-
-
-text {* We define three relations between well-orders:
-\begin{itemize}
-\item @{text "ordLeq"}, of being embedded (abbreviated @{text "\<le>o"});
-\item @{text "ordLess"}, of being strictly embedded (abbreviated @{text "<o"});
-\item @{text "ordIso"}, of being isomorphic (abbreviated @{text "=o"}).
-\end{itemize}
-%
-The prefix "ord" and the index "o" in these names stand for "ordinal-like".
-These relations shall be proved to be inter-connected in a similar fashion as the trio
-@{text "\<le>"}, @{text "<"}, @{text "="} associated to a total order on a set.
-*}
-
-
-definition ordLeq :: "('a rel * 'a' rel) set"
-where
-"ordLeq = {(r,r'). Well_order r \<and> Well_order r' \<and> (\<exists>f. embed r r' f)}"
-
-
-abbreviation ordLeq2 :: "'a rel \<Rightarrow> 'a' rel \<Rightarrow> bool" (infix "<=o" 50)
-where "r <=o r' \<equiv> (r,r') \<in> ordLeq"
-
-
-abbreviation ordLeq3 :: "'a rel \<Rightarrow> 'a' rel \<Rightarrow> bool" (infix "\<le>o" 50)
-where "r \<le>o r' \<equiv> r <=o r'"
-
-
-definition ordLess :: "('a rel * 'a' rel) set"
-where
-"ordLess = {(r,r'). Well_order r \<and> Well_order r' \<and> (\<exists>f. embedS r r' f)}"
-
-abbreviation ordLess2 :: "'a rel \<Rightarrow> 'a' rel \<Rightarrow> bool" (infix "<o" 50)
-where "r <o r' \<equiv> (r,r') \<in> ordLess"
-
-
-definition ordIso :: "('a rel * 'a' rel) set"
-where
-"ordIso = {(r,r'). Well_order r \<and> Well_order r' \<and> (\<exists>f. iso r r' f)}"
-
-abbreviation ordIso2 :: "'a rel \<Rightarrow> 'a' rel \<Rightarrow> bool" (infix "=o" 50)
-where "r =o r' \<equiv> (r,r') \<in> ordIso"
-
-
-lemmas ordRels_def = ordLeq_def ordLess_def ordIso_def
-
-lemma ordLeq_Well_order_simp:
-assumes "r \<le>o r'"
-shows "Well_order r \<and> Well_order r'"
-using assms unfolding ordLeq_def by simp
-
-
-text{* Notice that the relations @{text "\<le>o"}, @{text "<o"}, @{text "=o"} connect well-orders
-on potentially {\em distinct} types. However, some of the lemmas below, including the next one,
-restrict implicitly the type of these relations to @{text "(('a rel) * ('a rel)) set"} , i.e.,
-to @{text "'a rel rel"}.  *}
-
-
-lemma ordLeq_reflexive:
-"Well_order r \<Longrightarrow> r \<le>o r"
-unfolding ordLeq_def using id_embed[of r] by blast
-
-
-lemma ordLeq_transitive[trans]:
-assumes *: "r \<le>o r'" and **: "r' \<le>o r''"
-shows "r \<le>o r''"
-proof-
-  obtain f and f'
-  where 1: "Well_order r \<and> Well_order r' \<and> Well_order r''" and
-        "embed r r' f" and "embed r' r'' f'"
-  using * ** unfolding ordLeq_def by blast
-  hence "embed r r'' (f' o f)"
-  using comp_embed[of r r' f r'' f'] by auto
-  thus "r \<le>o r''" unfolding ordLeq_def using 1 by auto
-qed
-
-
-lemma ordLeq_total:
-"\<lbrakk>Well_order r; Well_order r'\<rbrakk> \<Longrightarrow> r \<le>o r' \<or> r' \<le>o r"
-unfolding ordLeq_def using wellorders_totally_ordered by blast
-
-
-lemma ordIso_reflexive:
-"Well_order r \<Longrightarrow> r =o r"
-unfolding ordIso_def using id_iso[of r] by blast
-
-
-lemma ordIso_transitive[trans]:
-assumes *: "r =o r'" and **: "r' =o r''"
-shows "r =o r''"
-proof-
-  obtain f and f'
-  where 1: "Well_order r \<and> Well_order r' \<and> Well_order r''" and
-        "iso r r' f" and 3: "iso r' r'' f'"
-  using * ** unfolding ordIso_def by auto
-  hence "iso r r'' (f' o f)"
-  using comp_iso[of r r' f r'' f'] by auto
-  thus "r =o r''" unfolding ordIso_def using 1 by auto
-qed
-
-
-lemma ordIso_symmetric:
-assumes *: "r =o r'"
-shows "r' =o r"
-proof-
-  obtain f where 1: "Well_order r \<and> Well_order r'" and
-                 2: "embed r r' f \<and> bij_betw f (Field r) (Field r')"
-  using * by (auto simp add: ordIso_def iso_def)
-  let ?f' = "inv_into (Field r) f"
-  have "embed r' r ?f' \<and> bij_betw ?f' (Field r') (Field r)"
-  using 1 2 by (simp add: bij_betw_inv_into inv_into_Field_embed_bij_betw)
-  thus "r' =o r" unfolding ordIso_def using 1 by (auto simp add: iso_def)
-qed
-
-
-lemma ordLeq_ordLess_trans[trans]:
-assumes "r \<le>o r'" and " r' <o r''"
-shows "r <o r''"
-proof-
-  have "Well_order r \<and> Well_order r''"
-  using assms unfolding ordLeq_def ordLess_def by auto
-  thus ?thesis using assms unfolding ordLeq_def ordLess_def
-  using embed_comp_embedS by blast
-qed
-
-
-lemma ordLess_ordLeq_trans[trans]:
-assumes "r <o r'" and " r' \<le>o r''"
-shows "r <o r''"
-proof-
-  have "Well_order r \<and> Well_order r''"
-  using assms unfolding ordLeq_def ordLess_def by auto
-  thus ?thesis using assms unfolding ordLeq_def ordLess_def
-  using embedS_comp_embed by blast
-qed
-
-
-lemma ordLeq_ordIso_trans[trans]:
-assumes "r \<le>o r'" and " r' =o r''"
-shows "r \<le>o r''"
-proof-
-  have "Well_order r \<and> Well_order r''"
-  using assms unfolding ordLeq_def ordIso_def by auto
-  thus ?thesis using assms unfolding ordLeq_def ordIso_def
-  using embed_comp_iso by blast
-qed
-
-
-lemma ordIso_ordLeq_trans[trans]:
-assumes "r =o r'" and " r' \<le>o r''"
-shows "r \<le>o r''"
-proof-
-  have "Well_order r \<and> Well_order r''"
-  using assms unfolding ordLeq_def ordIso_def by auto
-  thus ?thesis using assms unfolding ordLeq_def ordIso_def
-  using iso_comp_embed by blast
-qed
-
-
-lemma ordLess_ordIso_trans[trans]:
-assumes "r <o r'" and " r' =o r''"
-shows "r <o r''"
-proof-
-  have "Well_order r \<and> Well_order r''"
-  using assms unfolding ordLess_def ordIso_def by auto
-  thus ?thesis using assms unfolding ordLess_def ordIso_def
-  using embedS_comp_iso by blast
-qed
-
-
-lemma ordIso_ordLess_trans[trans]:
-assumes "r =o r'" and " r' <o r''"
-shows "r <o r''"
-proof-
-  have "Well_order r \<and> Well_order r''"
-  using assms unfolding ordLess_def ordIso_def by auto
-  thus ?thesis using assms unfolding ordLess_def ordIso_def
-  using iso_comp_embedS by blast
-qed
-
-
-lemma ordLess_not_embed:
-assumes "r <o r'"
-shows "\<not>(\<exists>f'. embed r' r f')"
-proof-
-  obtain f where 1: "Well_order r \<and> Well_order r'" and 2: "embed r r' f" and
-                 3: " \<not> bij_betw f (Field r) (Field r')"
-  using assms unfolding ordLess_def by (auto simp add: embedS_def)
-  {fix f' assume *: "embed r' r f'"
-   hence "bij_betw f (Field r) (Field r')" using 1 2
-   by (simp add: embed_bothWays_Field_bij_betw)
-   with 3 have False by contradiction
-  }
-  thus ?thesis by blast
-qed
-
-
-lemma ordLess_Field:
-assumes OL: "r1 <o r2" and EMB: "embed r1 r2 f"
-shows "\<not> (f`(Field r1) = Field r2)"
-proof-
-  let ?A1 = "Field r1"  let ?A2 = "Field r2"
-  obtain g where
-  0: "Well_order r1 \<and> Well_order r2" and
-  1: "embed r1 r2 g \<and> \<not>(bij_betw g ?A1 ?A2)"
-  using OL unfolding ordLess_def by (auto simp add: embedS_def)
-  hence "\<forall>a \<in> ?A1. f a = g a"
-  using 0 EMB embed_unique[of r1] by auto
-  hence "\<not>(bij_betw f ?A1 ?A2)"
-  using 1 bij_betw_cong[of ?A1] by blast
-  moreover
-  have "inj_on f ?A1" using EMB 0 by (simp add: embed_inj_on)
-  ultimately show ?thesis by (simp add: bij_betw_def)
-qed
-
-
-lemma ordLess_iff:
-"r <o r' = (Well_order r \<and> Well_order r' \<and> \<not>(\<exists>f'. embed r' r f'))"
-proof
-  assume *: "r <o r'"
-  hence "\<not>(\<exists>f'. embed r' r f')" using ordLess_not_embed[of r r'] by simp
-  with * show "Well_order r \<and> Well_order r' \<and> \<not> (\<exists>f'. embed r' r f')"
-  unfolding ordLess_def by auto
-next
-  assume *: "Well_order r \<and> Well_order r' \<and> \<not> (\<exists>f'. embed r' r f')"
-  then obtain f where 1: "embed r r' f"
-  using wellorders_totally_ordered[of r r'] by blast
-  moreover
-  {assume "bij_betw f (Field r) (Field r')"
-   with * 1 have "embed r' r (inv_into (Field r) f) "
-   using inv_into_Field_embed_bij_betw[of r r' f] by auto
-   with * have False by blast
-  }
-  ultimately show "(r,r') \<in> ordLess"
-  unfolding ordLess_def using * by (fastforce simp add: embedS_def)
-qed
-
-
-lemma ordLess_irreflexive: "\<not> r <o r"
-proof
-  assume "r <o r"
-  hence "Well_order r \<and>  \<not>(\<exists>f. embed r r f)"
-  unfolding ordLess_iff ..
-  moreover have "embed r r id" using id_embed[of r] .
-  ultimately show False by blast
-qed
-
-
-lemma ordLeq_iff_ordLess_or_ordIso:
-"r \<le>o r' = (r <o r' \<or> r =o r')"
-unfolding ordRels_def embedS_defs iso_defs by blast
-
-
-lemma ordIso_iff_ordLeq:
-"(r =o r') = (r \<le>o r' \<and> r' \<le>o r)"
-proof
-  assume "r =o r'"
-  then obtain f where 1: "Well_order r \<and> Well_order r' \<and>
-                     embed r r' f \<and> bij_betw f (Field r) (Field r')"
-  unfolding ordIso_def iso_defs by auto
-  hence "embed r r' f \<and> embed r' r (inv_into (Field r) f)"
-  by (simp add: inv_into_Field_embed_bij_betw)
-  thus  "r \<le>o r' \<and> r' \<le>o r"
-  unfolding ordLeq_def using 1 by auto
-next
-  assume "r \<le>o r' \<and> r' \<le>o r"
-  then obtain f and g where 1: "Well_order r \<and> Well_order r' \<and>
-                           embed r r' f \<and> embed r' r g"
-  unfolding ordLeq_def by auto
-  hence "iso r r' f" by (auto simp add: embed_bothWays_iso)
-  thus "r =o r'" unfolding ordIso_def using 1 by auto
-qed
-
-
-lemma not_ordLess_ordLeq:
-"r <o r' \<Longrightarrow> \<not> r' \<le>o r"
-using ordLess_ordLeq_trans ordLess_irreflexive by blast
-
-
-lemma ordLess_or_ordLeq:
-assumes WELL: "Well_order r" and WELL': "Well_order r'"
-shows "r <o r' \<or> r' \<le>o r"
-proof-
-  have "r \<le>o r' \<or> r' \<le>o r"
-  using assms by (simp add: ordLeq_total)
-  moreover
-  {assume "\<not> r <o r' \<and> r \<le>o r'"
-   hence "r =o r'" using ordLeq_iff_ordLess_or_ordIso by blast
-   hence "r' \<le>o r" using ordIso_symmetric ordIso_iff_ordLeq by blast
-  }
-  ultimately show ?thesis by blast
-qed
-
-
-lemma not_ordLess_ordIso:
-"r <o r' \<Longrightarrow> \<not> r =o r'"
-using assms ordLess_ordIso_trans ordIso_symmetric ordLess_irreflexive by blast
-
-
-lemma not_ordLeq_iff_ordLess:
-assumes WELL: "Well_order r" and WELL': "Well_order r'"
-shows "(\<not> r' \<le>o r) = (r <o r')"
-using assms not_ordLess_ordLeq ordLess_or_ordLeq by blast
-
-
-lemma not_ordLess_iff_ordLeq:
-assumes WELL: "Well_order r" and WELL': "Well_order r'"
-shows "(\<not> r' <o r) = (r \<le>o r')"
-using assms not_ordLess_ordLeq ordLess_or_ordLeq by blast
-
-
-lemma ordLess_transitive[trans]:
-"\<lbrakk>r <o r'; r' <o r''\<rbrakk> \<Longrightarrow> r <o r''"
-using assms ordLess_ordLeq_trans ordLeq_iff_ordLess_or_ordIso by blast
-
-
-corollary ordLess_trans: "trans ordLess"
-unfolding trans_def using ordLess_transitive by blast
-
-
-lemmas ordIso_equivalence = ordIso_transitive ordIso_reflexive ordIso_symmetric
-
-
-lemma ordIso_imp_ordLeq:
-"r =o r' \<Longrightarrow> r \<le>o r'"
-using ordIso_iff_ordLeq by blast
-
-
-lemma ordLess_imp_ordLeq:
-"r <o r' \<Longrightarrow> r \<le>o r'"
-using ordLeq_iff_ordLess_or_ordIso by blast
-
-
-lemma ofilter_subset_ordLeq:
-assumes WELL: "Well_order r" and
-        OFA: "wo_rel.ofilter r A" and OFB: "wo_rel.ofilter r B"
-shows "(A \<le> B) = (Restr r A \<le>o Restr r B)"
-proof
-  assume "A \<le> B"
-  thus "Restr r A \<le>o Restr r B"
-  unfolding ordLeq_def using assms
-  Well_order_Restr Well_order_Restr ofilter_subset_embed by blast
-next
-  assume *: "Restr r A \<le>o Restr r B"
-  then obtain f where "embed (Restr r A) (Restr r B) f"
-  unfolding ordLeq_def by blast
-  {assume "B < A"
-   hence "Restr r B <o Restr r A"
-   unfolding ordLess_def using assms
-   Well_order_Restr Well_order_Restr ofilter_subset_embedS by blast
-   hence False using * not_ordLess_ordLeq by blast
-  }
-  thus "A \<le> B" using OFA OFB WELL
-  wo_rel_def[of r] wo_rel.ofilter_linord[of r A B] by blast
-qed
-
-
-lemma ofilter_subset_ordLess:
-assumes WELL: "Well_order r" and
-        OFA: "wo_rel.ofilter r A" and OFB: "wo_rel.ofilter r B"
-shows "(A < B) = (Restr r A <o Restr r B)"
-proof-
-  let ?rA = "Restr r A" let ?rB = "Restr r B"
-  have 1: "Well_order ?rA \<and> Well_order ?rB"
-  using WELL Well_order_Restr by blast
-  have "(A < B) = (\<not> B \<le> A)" using assms
-  wo_rel_def wo_rel.ofilter_linord[of r A B] by blast
-  also have "\<dots> = (\<not> Restr r B \<le>o Restr r A)"
-  using assms ofilter_subset_ordLeq by blast
-  also have "\<dots> = (Restr r A <o Restr r B)"
-  using 1 not_ordLeq_iff_ordLess by blast
-  finally show ?thesis .
-qed
-
-
-lemma ofilter_ordLess:
-"\<lbrakk>Well_order r; wo_rel.ofilter r A\<rbrakk> \<Longrightarrow> (A < Field r) = (Restr r A <o r)"
-by (simp add: ofilter_subset_ordLess wo_rel.Field_ofilter
-    wo_rel_def Restr_Field)
-
-
-corollary underS_Restr_ordLess:
-assumes "Well_order r" and "Field r \<noteq> {}"
-shows "Restr r (underS r a) <o r"
-proof-
-  have "underS r a < Field r" using assms
-  by (simp add: underS_Field3)
-  thus ?thesis using assms
-  by (simp add: ofilter_ordLess wo_rel.underS_ofilter wo_rel_def)
-qed
-
-
-lemma embed_ordLess_ofilterIncl:
-assumes
-  OL12: "r1 <o r2" and OL23: "r2 <o r3" and
-  EMB13: "embed r1 r3 f13" and EMB23: "embed r2 r3 f23"
-shows "(f13`(Field r1), f23`(Field r2)) \<in> (ofilterIncl r3)"
-proof-
-  have OL13: "r1 <o r3"
-  using OL12 OL23 using ordLess_transitive by auto
-  let ?A1 = "Field r1"  let ?A2 ="Field r2" let ?A3 ="Field r3"
-  obtain f12 g23 where
-  0: "Well_order r1 \<and> Well_order r2 \<and> Well_order r3" and
-  1: "embed r1 r2 f12 \<and> \<not>(bij_betw f12 ?A1 ?A2)" and
-  2: "embed r2 r3 g23 \<and> \<not>(bij_betw g23 ?A2 ?A3)"
-  using OL12 OL23 by (auto simp add: ordLess_def embedS_def)
-  hence "\<forall>a \<in> ?A2. f23 a = g23 a"
-  using EMB23 embed_unique[of r2 r3] by blast
-  hence 3: "\<not>(bij_betw f23 ?A2 ?A3)"
-  using 2 bij_betw_cong[of ?A2 f23 g23] by blast
-  (*  *)
-  have 4: "wo_rel.ofilter r2 (f12 ` ?A1) \<and> f12 ` ?A1 \<noteq> ?A2"
-  using 0 1 OL12 by (simp add: embed_Field_ofilter ordLess_Field)
-  have 5: "wo_rel.ofilter r3 (f23 ` ?A2) \<and> f23 ` ?A2 \<noteq> ?A3"
-  using 0 EMB23 OL23 by (simp add: embed_Field_ofilter ordLess_Field)
-  have 6: "wo_rel.ofilter r3 (f13 ` ?A1)  \<and> f13 ` ?A1 \<noteq> ?A3"
-  using 0 EMB13 OL13 by (simp add: embed_Field_ofilter ordLess_Field)
-  (*  *)
-  have "f12 ` ?A1 < ?A2"
-  using 0 4 by (auto simp add: wo_rel_def wo_rel.ofilter_def)
-  moreover have "inj_on f23 ?A2"
-  using EMB23 0 by (simp add: wo_rel_def embed_inj_on)
-  ultimately
-  have "f23 ` (f12 ` ?A1) < f23 ` ?A2" by (simp add: inj_on_strict_subset)
-  moreover
-  {have "embed r1 r3 (f23 o f12)"
-   using 1 EMB23 0 by (auto simp add: comp_embed)
-   hence "\<forall>a \<in> ?A1. f23(f12 a) = f13 a"
-   using EMB13 0 embed_unique[of r1 r3 "f23 o f12" f13] by auto
-   hence "f23 ` (f12 ` ?A1) = f13 ` ?A1" by force
-  }
-  ultimately
-  have "f13 ` ?A1 < f23 ` ?A2" by simp
-  (*  *)
-  with 5 6 show ?thesis
-  unfolding ofilterIncl_def by auto
-qed
-
-
-lemma ordLess_iff_ordIso_Restr:
-assumes WELL: "Well_order r" and WELL': "Well_order r'"
-shows "(r' <o r) = (\<exists>a \<in> Field r. r' =o Restr r (underS r a))"
-proof(auto)
-  fix a assume *: "a \<in> Field r" and **: "r' =o Restr r (underS r a)"
-  hence "Restr r (underS r a) <o r" using WELL underS_Restr_ordLess[of r] by blast
-  thus "r' <o r" using ** ordIso_ordLess_trans by blast
-next
-  assume "r' <o r"
-  then obtain f where 1: "Well_order r \<and> Well_order r'" and
-                      2: "embed r' r f \<and> f ` (Field r') \<noteq> Field r"
-  unfolding ordLess_def embedS_def[abs_def] bij_betw_def using embed_inj_on by blast
-  hence "wo_rel.ofilter r (f ` (Field r'))" using embed_Field_ofilter by blast
-  then obtain a where 3: "a \<in> Field r" and 4: "underS r a = f ` (Field r')"
-  using 1 2 by (auto simp add: wo_rel.ofilter_underS_Field wo_rel_def)
-  have "iso r' (Restr r (f ` (Field r'))) f"
-  using embed_implies_iso_Restr 2 assms by blast
-  moreover have "Well_order (Restr r (f ` (Field r')))"
-  using WELL Well_order_Restr by blast
-  ultimately have "r' =o Restr r (f ` (Field r'))"
-  using WELL' unfolding ordIso_def by auto
-  hence "r' =o Restr r (underS r a)" using 4 by auto
-  thus "\<exists>a \<in> Field r. r' =o Restr r (underS r a)" using 3 by auto
-qed
-
-
-lemma internalize_ordLess:
-"(r' <o r) = (\<exists>p. Field p < Field r \<and> r' =o p \<and> p <o r)"
-proof
-  assume *: "r' <o r"
-  hence 0: "Well_order r \<and> Well_order r'" unfolding ordLess_def by auto
-  with * obtain a where 1: "a \<in> Field r" and 2: "r' =o Restr r (underS r a)"
-  using ordLess_iff_ordIso_Restr by blast
-  let ?p = "Restr r (underS r a)"
-  have "wo_rel.ofilter r (underS r a)" using 0
-  by (simp add: wo_rel_def wo_rel.underS_ofilter)
-  hence "Field ?p = underS r a" using 0 Field_Restr_ofilter by blast
-  hence "Field ?p < Field r" using underS_Field2 1 by fast
-  moreover have "?p <o r" using underS_Restr_ordLess[of r a] 0 1 by blast
-  ultimately
-  show "\<exists>p. Field p < Field r \<and> r' =o p \<and> p <o r" using 2 by blast
-next
-  assume "\<exists>p. Field p < Field r \<and> r' =o p \<and> p <o r"
-  thus "r' <o r" using ordIso_ordLess_trans by blast
-qed
-
-
-lemma internalize_ordLeq:
-"(r' \<le>o r) = (\<exists>p. Field p \<le> Field r \<and> r' =o p \<and> p \<le>o r)"
-proof
-  assume *: "r' \<le>o r"
-  moreover
-  {assume "r' <o r"
-   then obtain p where "Field p < Field r \<and> r' =o p \<and> p <o r"
-   using internalize_ordLess[of r' r] by blast
-   hence "\<exists>p. Field p \<le> Field r \<and> r' =o p \<and> p \<le>o r"
-   using ordLeq_iff_ordLess_or_ordIso by blast
-  }
-  moreover
-  have "r \<le>o r" using * ordLeq_def ordLeq_reflexive by blast
-  ultimately show "\<exists>p. Field p \<le> Field r \<and> r' =o p \<and> p \<le>o r"
-  using ordLeq_iff_ordLess_or_ordIso by blast
-next
-  assume "\<exists>p. Field p \<le> Field r \<and> r' =o p \<and> p \<le>o r"
-  thus "r' \<le>o r" using ordIso_ordLeq_trans by blast
-qed
-
-
-lemma ordLeq_iff_ordLess_Restr:
-assumes WELL: "Well_order r" and WELL': "Well_order r'"
-shows "(r \<le>o r') = (\<forall>a \<in> Field r. Restr r (underS r a) <o r')"
-proof(auto)
-  assume *: "r \<le>o r'"
-  fix a assume "a \<in> Field r"
-  hence "Restr r (underS r a) <o r"
-  using WELL underS_Restr_ordLess[of r] by blast
-  thus "Restr r (underS r a) <o r'"
-  using * ordLess_ordLeq_trans by blast
-next
-  assume *: "\<forall>a \<in> Field r. Restr r (underS r a) <o r'"
-  {assume "r' <o r"
-   then obtain a where "a \<in> Field r \<and> r' =o Restr r (underS r a)"
-   using assms ordLess_iff_ordIso_Restr by blast
-   hence False using * not_ordLess_ordIso ordIso_symmetric by blast
-  }
-  thus "r \<le>o r'" using ordLess_or_ordLeq assms by blast
-qed
-
-
-lemma finite_ordLess_infinite:
-assumes WELL: "Well_order r" and WELL': "Well_order r'" and
-        FIN: "finite(Field r)" and INF: "\<not>finite(Field r')"
-shows "r <o r'"
-proof-
-  {assume "r' \<le>o r"
-   then obtain h where "inj_on h (Field r') \<and> h ` (Field r') \<le> Field r"
-   unfolding ordLeq_def using assms embed_inj_on embed_Field by blast
-   hence False using finite_imageD finite_subset FIN INF by metis
-  }
-  thus ?thesis using WELL WELL' ordLess_or_ordLeq by blast
-qed
-
-
-lemma finite_well_order_on_ordIso:
-assumes FIN: "finite A" and
-        WELL: "well_order_on A r" and WELL': "well_order_on A r'"
-shows "r =o r'"
-proof-
-  have 0: "Well_order r \<and> Well_order r' \<and> Field r = A \<and> Field r' = A"
-  using assms well_order_on_Well_order by blast
-  moreover
-  have "\<forall>r r'. well_order_on A r \<and> well_order_on A r' \<and> r \<le>o r'
-                  \<longrightarrow> r =o r'"
-  proof(clarify)
-    fix r r' assume *: "well_order_on A r" and **: "well_order_on A r'"
-    have 2: "Well_order r \<and> Well_order r' \<and> Field r = A \<and> Field r' = A"
-    using * ** well_order_on_Well_order by blast
-    assume "r \<le>o r'"
-    then obtain f where 1: "embed r r' f" and
-                        "inj_on f A \<and> f ` A \<le> A"
-    unfolding ordLeq_def using 2 embed_inj_on embed_Field by blast
-    hence "bij_betw f A A" unfolding bij_betw_def using FIN endo_inj_surj by blast
-    thus "r =o r'" unfolding ordIso_def iso_def[abs_def] using 1 2 by auto
-  qed
-  ultimately show ?thesis using assms ordLeq_total ordIso_symmetric by metis
-qed
-
-
-subsection{* @{text "<o"} is well-founded *}
-
-
-text {* Of course, it only makes sense to state that the @{text "<o"} is well-founded
-on the restricted type @{text "'a rel rel"}.  We prove this by first showing that, for any set
-of well-orders all embedded in a fixed well-order, the function mapping each well-order
-in the set to an order filter of the fixed well-order is compatible w.r.t. to @{text "<o"} versus
-{\em strict inclusion}; and we already know that strict inclusion of order filters is well-founded. *}
-
-
-definition ord_to_filter :: "'a rel \<Rightarrow> 'a rel \<Rightarrow> 'a set"
-where "ord_to_filter r0 r \<equiv> (SOME f. embed r r0 f) ` (Field r)"
-
-
-lemma ord_to_filter_compat:
-"compat (ordLess Int (ordLess^-1``{r0} \<times> ordLess^-1``{r0}))
-        (ofilterIncl r0)
-        (ord_to_filter r0)"
-proof(unfold compat_def ord_to_filter_def, clarify)
-  fix r1::"'a rel" and r2::"'a rel"
-  let ?A1 = "Field r1"  let ?A2 ="Field r2" let ?A0 ="Field r0"
-  let ?phi10 = "\<lambda> f10. embed r1 r0 f10" let ?f10 = "SOME f. ?phi10 f"
-  let ?phi20 = "\<lambda> f20. embed r2 r0 f20" let ?f20 = "SOME f. ?phi20 f"
-  assume *: "r1 <o r0" "r2 <o r0" and **: "r1 <o r2"
-  hence "(\<exists>f. ?phi10 f) \<and> (\<exists>f. ?phi20 f)"
-  by (auto simp add: ordLess_def embedS_def)
-  hence "?phi10 ?f10 \<and> ?phi20 ?f20" by (auto simp add: someI_ex)
-  thus "(?f10 ` ?A1, ?f20 ` ?A2) \<in> ofilterIncl r0"
-  using * ** by (simp add: embed_ordLess_ofilterIncl)
-qed
-
-
-theorem wf_ordLess: "wf ordLess"
-proof-
-  {fix r0 :: "('a \<times> 'a) set"
-   (* need to annotate here!*)
-   let ?ordLess = "ordLess::('d rel * 'd rel) set"
-   let ?R = "?ordLess Int (?ordLess^-1``{r0} \<times> ?ordLess^-1``{r0})"
-   {assume Case1: "Well_order r0"
-    hence "wf ?R"
-    using wf_ofilterIncl[of r0]
-          compat_wf[of ?R "ofilterIncl r0" "ord_to_filter r0"]
-          ord_to_filter_compat[of r0] by auto
-   }
-   moreover
-   {assume Case2: "\<not> Well_order r0"
-    hence "?R = {}" unfolding ordLess_def by auto
-    hence "wf ?R" using wf_empty by simp
-   }
-   ultimately have "wf ?R" by blast
-  }
-  thus ?thesis by (simp add: trans_wf_iff ordLess_trans)
-qed
-
-corollary exists_minim_Well_order:
-assumes NE: "R \<noteq> {}" and WELL: "\<forall>r \<in> R. Well_order r"
-shows "\<exists>r \<in> R. \<forall>r' \<in> R. r \<le>o r'"
-proof-
-  obtain r where "r \<in> R \<and> (\<forall>r' \<in> R. \<not> r' <o r)"
-  using NE spec[OF spec[OF subst[OF wf_eq_minimal, of "%x. x", OF wf_ordLess]], of _ R]
-    equals0I[of R] by blast
-  with not_ordLeq_iff_ordLess WELL show ?thesis by blast
-qed
-
-
-
-subsection {* Copy via direct images  *}
-
-
-text{* The direct image operator is the dual of the inverse image operator @{text "inv_image"}
-from @{text "Relation.thy"}.  It is useful for transporting a well-order between
-different types. *}
-
-
-definition dir_image :: "'a rel \<Rightarrow> ('a \<Rightarrow> 'a') \<Rightarrow> 'a' rel"
-where
-"dir_image r f = {(f a, f b)| a b. (a,b) \<in> r}"
-
-
-lemma dir_image_Field:
-"Field(dir_image r f) \<le> f ` (Field r)"
-unfolding dir_image_def Field_def by auto
-
-
-lemma dir_image_minus_Id:
-"inj_on f (Field r) \<Longrightarrow> (dir_image r f) - Id = dir_image (r - Id) f"
-unfolding inj_on_def Field_def dir_image_def by auto
-
-
-lemma Refl_dir_image:
-assumes "Refl r"
-shows "Refl(dir_image r f)"
-proof-
-  {fix a' b'
-   assume "(a',b') \<in> dir_image r f"
-   then obtain a b where 1: "a' = f a \<and> b' = f b \<and> (a,b) \<in> r"
-   unfolding dir_image_def by blast
-   hence "a \<in> Field r \<and> b \<in> Field r" using Field_def by fastforce
-   hence "(a,a) \<in> r \<and> (b,b) \<in> r" using assms by (simp add: refl_on_def)
-   with 1 have "(a',a') \<in> dir_image r f \<and> (b',b') \<in> dir_image r f"
-   unfolding dir_image_def by auto
-  }
-  thus ?thesis
-  by(unfold refl_on_def Field_def Domain_def Range_def, auto)
-qed
-
-
-lemma trans_dir_image:
-assumes TRANS: "trans r" and INJ: "inj_on f (Field r)"
-shows "trans(dir_image r f)"
-proof(unfold trans_def, auto)
-  fix a' b' c'
-  assume "(a',b') \<in> dir_image r f" "(b',c') \<in> dir_image r f"
-  then obtain a b1 b2 c where 1: "a' = f a \<and> b' = f b1 \<and> b' = f b2 \<and> c' = f c" and
-                         2: "(a,b1) \<in> r \<and> (b2,c) \<in> r"
-  unfolding dir_image_def by blast
-  hence "b1 \<in> Field r \<and> b2 \<in> Field r"
-  unfolding Field_def by auto
-  hence "b1 = b2" using 1 INJ unfolding inj_on_def by auto
-  hence "(a,c): r" using 2 TRANS unfolding trans_def by blast
-  thus "(a',c') \<in> dir_image r f"
-  unfolding dir_image_def using 1 by auto
-qed
-
-
-lemma Preorder_dir_image:
-"\<lbrakk>Preorder r; inj_on f (Field r)\<rbrakk> \<Longrightarrow> Preorder (dir_image r f)"
-by (simp add: preorder_on_def Refl_dir_image trans_dir_image)
-
-
-lemma antisym_dir_image:
-assumes AN: "antisym r" and INJ: "inj_on f (Field r)"
-shows "antisym(dir_image r f)"
-proof(unfold antisym_def, auto)
-  fix a' b'
-  assume "(a',b') \<in> dir_image r f" "(b',a') \<in> dir_image r f"
-  then obtain a1 b1 a2 b2 where 1: "a' = f a1 \<and> a' = f a2 \<and> b' = f b1 \<and> b' = f b2" and
-                           2: "(a1,b1) \<in> r \<and> (b2,a2) \<in> r " and
-                           3: "{a1,a2,b1,b2} \<le> Field r"
-  unfolding dir_image_def Field_def by blast
-  hence "a1 = a2 \<and> b1 = b2" using INJ unfolding inj_on_def by auto
-  hence "a1 = b2" using 2 AN unfolding antisym_def by auto
-  thus "a' = b'" using 1 by auto
-qed
-
-
-lemma Partial_order_dir_image:
-"\<lbrakk>Partial_order r; inj_on f (Field r)\<rbrakk> \<Longrightarrow> Partial_order (dir_image r f)"
-by (simp add: partial_order_on_def Preorder_dir_image antisym_dir_image)
-
-
-lemma Total_dir_image:
-assumes TOT: "Total r" and INJ: "inj_on f (Field r)"
-shows "Total(dir_image r f)"
-proof(unfold total_on_def, intro ballI impI)
-  fix a' b'
-  assume "a' \<in> Field (dir_image r f)" "b' \<in> Field (dir_image r f)"
-  then obtain a and b where 1: "a \<in> Field r \<and> b \<in> Field r \<and> f a = a' \<and> f b = b'"
-  using dir_image_Field[of r f] by blast
-  moreover assume "a' \<noteq> b'"
-  ultimately have "a \<noteq> b" using INJ unfolding inj_on_def by auto
-  hence "(a,b) \<in> r \<or> (b,a) \<in> r" using 1 TOT unfolding total_on_def by auto
-  thus "(a',b') \<in> dir_image r f \<or> (b',a') \<in> dir_image r f"
-  using 1 unfolding dir_image_def by auto
-qed
-
-
-lemma Linear_order_dir_image:
-"\<lbrakk>Linear_order r; inj_on f (Field r)\<rbrakk> \<Longrightarrow> Linear_order (dir_image r f)"
-by (simp add: linear_order_on_def Partial_order_dir_image Total_dir_image)
-
-
-lemma wf_dir_image:
-assumes WF: "wf r" and INJ: "inj_on f (Field r)"
-shows "wf(dir_image r f)"
-proof(unfold wf_eq_minimal2, intro allI impI, elim conjE)
-  fix A'::"'b set"
-  assume SUB: "A' \<le> Field(dir_image r f)" and NE: "A' \<noteq> {}"
-  obtain A where A_def: "A = {a \<in> Field r. f a \<in> A'}" by blast
-  have "A \<noteq> {} \<and> A \<le> Field r"
-  using A_def dir_image_Field[of r f] SUB NE by blast
-  then obtain a where 1: "a \<in> A \<and> (\<forall>b \<in> A. (b,a) \<notin> r)"
-  using WF unfolding wf_eq_minimal2 by metis
-  have "\<forall>b' \<in> A'. (b',f a) \<notin> dir_image r f"
-  proof(clarify)
-    fix b' assume *: "b' \<in> A'" and **: "(b',f a) \<in> dir_image r f"
-    obtain b1 a1 where 2: "b' = f b1 \<and> f a = f a1" and
-                       3: "(b1,a1) \<in> r \<and> {a1,b1} \<le> Field r"
-    using ** unfolding dir_image_def Field_def by blast
-    hence "a = a1" using 1 A_def INJ unfolding inj_on_def by auto
-    hence "b1 \<in> A \<and> (b1,a) \<in> r" using 2 3 A_def * by auto
-    with 1 show False by auto
-  qed
-  thus "\<exists>a'\<in>A'. \<forall>b'\<in>A'. (b', a') \<notin> dir_image r f"
-  using A_def 1 by blast
-qed
-
-
-lemma Well_order_dir_image:
-"\<lbrakk>Well_order r; inj_on f (Field r)\<rbrakk> \<Longrightarrow> Well_order (dir_image r f)"
-using assms unfolding well_order_on_def
-using Linear_order_dir_image[of r f] wf_dir_image[of "r - Id" f]
-  dir_image_minus_Id[of f r]
-  subset_inj_on[of f "Field r" "Field(r - Id)"]
-  mono_Field[of "r - Id" r] by auto
-
-
-lemma dir_image_Field2:
-"Refl r \<Longrightarrow> Field(dir_image r f) = f ` (Field r)"
-unfolding Field_def dir_image_def refl_on_def Domain_def Range_def by blast
-
-
-lemma dir_image_bij_betw:
-"\<lbrakk>Well_order r; inj_on f (Field r)\<rbrakk> \<Longrightarrow> bij_betw f (Field r) (Field (dir_image r f))"
-unfolding bij_betw_def
-by (simp add: dir_image_Field2 order_on_defs)
-
-
-lemma dir_image_compat:
-"compat r (dir_image r f) f"
-unfolding compat_def dir_image_def by auto
-
-
-lemma dir_image_iso:
-"\<lbrakk>Well_order r; inj_on f (Field r)\<rbrakk>  \<Longrightarrow> iso r (dir_image r f) f"
-using iso_iff3 dir_image_compat dir_image_bij_betw Well_order_dir_image by blast
-
-
-lemma dir_image_ordIso:
-"\<lbrakk>Well_order r; inj_on f (Field r)\<rbrakk>  \<Longrightarrow> r =o dir_image r f"
-unfolding ordIso_def using dir_image_iso Well_order_dir_image by blast
-
-
-lemma Well_order_iso_copy:
-assumes WELL: "well_order_on A r" and BIJ: "bij_betw f A A'"
-shows "\<exists>r'. well_order_on A' r' \<and> r =o r'"
-proof-
-   let ?r' = "dir_image r f"
-   have 1: "A = Field r \<and> Well_order r"
-   using WELL well_order_on_Well_order by blast
-   hence 2: "iso r ?r' f"
-   using dir_image_iso using BIJ unfolding bij_betw_def by auto
-   hence "f ` (Field r) = Field ?r'" using 1 iso_iff[of r ?r'] by blast
-   hence "Field ?r' = A'"
-   using 1 BIJ unfolding bij_betw_def by auto
-   moreover have "Well_order ?r'"
-   using 1 Well_order_dir_image BIJ unfolding bij_betw_def by blast
-   ultimately show ?thesis unfolding ordIso_def using 1 2 by blast
-qed
-
-
-
-subsection {* Bounded square  *}
-
-
-text{* This construction essentially defines, for an order relation @{text "r"}, a lexicographic
-order @{text "bsqr r"} on @{text "(Field r) \<times> (Field r)"}, applying the
-following criteria (in this order):
-\begin{itemize}
-\item compare the maximums;
-\item compare the first components;
-\item compare the second components.
-\end{itemize}
-%
-The only application of this construction that we are aware of is
-at proving that the square of an infinite set has the same cardinal
-as that set. The essential property required there (and which is ensured by this
-construction) is that any proper order filter of the product order is included in a rectangle, i.e.,
-in a product of proper filters on the original relation (assumed to be a well-order). *}
-
-
-definition bsqr :: "'a rel => ('a * 'a)rel"
-where
-"bsqr r = {((a1,a2),(b1,b2)).
-           {a1,a2,b1,b2} \<le> Field r \<and>
-           (a1 = b1 \<and> a2 = b2 \<or>
-            (wo_rel.max2 r a1 a2, wo_rel.max2 r b1 b2) \<in> r - Id \<or>
-            wo_rel.max2 r a1 a2 = wo_rel.max2 r b1 b2 \<and> (a1,b1) \<in> r - Id \<or>
-            wo_rel.max2 r a1 a2 = wo_rel.max2 r b1 b2 \<and> a1 = b1  \<and> (a2,b2) \<in> r - Id
-           )}"
-
-
-lemma Field_bsqr:
-"Field (bsqr r) = Field r \<times> Field r"
-proof
-  show "Field (bsqr r) \<le> Field r \<times> Field r"
-  proof-
-    {fix a1 a2 assume "(a1,a2) \<in> Field (bsqr r)"
-     moreover
-     have "\<And> b1 b2. ((a1,a2),(b1,b2)) \<in> bsqr r \<or> ((b1,b2),(a1,a2)) \<in> bsqr r \<Longrightarrow>
-                      a1 \<in> Field r \<and> a2 \<in> Field r" unfolding bsqr_def by auto
-     ultimately have "a1 \<in> Field r \<and> a2 \<in> Field r" unfolding Field_def by auto
-    }
-    thus ?thesis unfolding Field_def by force
-  qed
-next
-  show "Field r \<times> Field r \<le> Field (bsqr r)"
-  proof(auto)
-    fix a1 a2 assume "a1 \<in> Field r" and "a2 \<in> Field r"
-    hence "((a1,a2),(a1,a2)) \<in> bsqr r" unfolding bsqr_def by blast
-    thus "(a1,a2) \<in> Field (bsqr r)" unfolding Field_def by auto
-  qed
-qed
-
-
-lemma bsqr_Refl: "Refl(bsqr r)"
-by(unfold refl_on_def Field_bsqr, auto simp add: bsqr_def)
-
-
-lemma bsqr_Trans:
-assumes "Well_order r"
-shows "trans (bsqr r)"
-proof(unfold trans_def, auto)
-  (* Preliminary facts *)
-  have Well: "wo_rel r" using assms wo_rel_def by auto
-  hence Trans: "trans r" using wo_rel.TRANS by auto
-  have Anti: "antisym r" using wo_rel.ANTISYM Well by auto
-  hence TransS: "trans(r - Id)" using Trans by (simp add: trans_diff_Id)
-  (* Main proof *)
-  fix a1 a2 b1 b2 c1 c2
-  assume *: "((a1,a2),(b1,b2)) \<in> bsqr r" and **: "((b1,b2),(c1,c2)) \<in> bsqr r"
-  hence 0: "{a1,a2,b1,b2,c1,c2} \<le> Field r" unfolding bsqr_def by auto
-  have 1: "a1 = b1 \<and> a2 = b2 \<or> (wo_rel.max2 r a1 a2, wo_rel.max2 r b1 b2) \<in> r - Id \<or>
-           wo_rel.max2 r a1 a2 = wo_rel.max2 r b1 b2 \<and> (a1,b1) \<in> r - Id \<or>
-           wo_rel.max2 r a1 a2 = wo_rel.max2 r b1 b2 \<and> a1 = b1 \<and> (a2,b2) \<in> r - Id"
-  using * unfolding bsqr_def by auto
-  have 2: "b1 = c1 \<and> b2 = c2 \<or> (wo_rel.max2 r b1 b2, wo_rel.max2 r c1 c2) \<in> r - Id \<or>
-           wo_rel.max2 r b1 b2 = wo_rel.max2 r c1 c2 \<and> (b1,c1) \<in> r - Id \<or>
-           wo_rel.max2 r b1 b2 = wo_rel.max2 r c1 c2 \<and> b1 = c1 \<and> (b2,c2) \<in> r - Id"
-  using ** unfolding bsqr_def by auto
-  show "((a1,a2),(c1,c2)) \<in> bsqr r"
-  proof-
-    {assume Case1: "a1 = b1 \<and> a2 = b2"
-     hence ?thesis using ** by simp
-    }
-    moreover
-    {assume Case2: "(wo_rel.max2 r a1 a2, wo_rel.max2 r b1 b2) \<in> r - Id"
-     {assume Case21: "b1 = c1 \<and> b2 = c2"
-      hence ?thesis using * by simp
-     }
-     moreover
-     {assume Case22: "(wo_rel.max2 r b1 b2, wo_rel.max2 r c1 c2) \<in> r - Id"
-      hence "(wo_rel.max2 r a1 a2, wo_rel.max2 r c1 c2) \<in> r - Id"
-      using Case2 TransS trans_def[of "r - Id"] by blast
-      hence ?thesis using 0 unfolding bsqr_def by auto
-     }
-     moreover
-     {assume Case23_4: "wo_rel.max2 r b1 b2 = wo_rel.max2 r c1 c2"
-      hence ?thesis using Case2 0 unfolding bsqr_def by auto
-     }
-     ultimately have ?thesis using 0 2 by auto
-    }
-    moreover
-    {assume Case3: "wo_rel.max2 r a1 a2 = wo_rel.max2 r b1 b2 \<and> (a1,b1) \<in> r - Id"
-     {assume Case31: "b1 = c1 \<and> b2 = c2"
-      hence ?thesis using * by simp
-     }
-     moreover
-     {assume Case32: "(wo_rel.max2 r b1 b2, wo_rel.max2 r c1 c2) \<in> r - Id"
-      hence ?thesis using Case3 0 unfolding bsqr_def by auto
-     }
-     moreover
-     {assume Case33: "wo_rel.max2 r b1 b2 = wo_rel.max2 r c1 c2 \<and> (b1,c1) \<in> r - Id"
-      hence "(a1,c1) \<in> r - Id"
-      using Case3 TransS trans_def[of "r - Id"] by blast
-      hence ?thesis using Case3 Case33 0 unfolding bsqr_def by auto
-     }
-     moreover
-     {assume Case33: "wo_rel.max2 r b1 b2 = wo_rel.max2 r c1 c2 \<and> b1 = c1"
-      hence ?thesis using Case3 0 unfolding bsqr_def by auto
-     }
-     ultimately have ?thesis using 0 2 by auto
-    }
-    moreover
-    {assume Case4: "wo_rel.max2 r a1 a2 = wo_rel.max2 r b1 b2 \<and> a1 = b1 \<and> (a2,b2) \<in> r - Id"
-     {assume Case41: "b1 = c1 \<and> b2 = c2"
-      hence ?thesis using * by simp
-     }
-     moreover
-     {assume Case42: "(wo_rel.max2 r b1 b2, wo_rel.max2 r c1 c2) \<in> r - Id"
-      hence ?thesis using Case4 0 unfolding bsqr_def by force
-     }
-     moreover
-     {assume Case43: "wo_rel.max2 r b1 b2 = wo_rel.max2 r c1 c2 \<and> (b1,c1) \<in> r - Id"
-      hence ?thesis using Case4 0 unfolding bsqr_def by auto
-     }
-     moreover
-     {assume Case44: "wo_rel.max2 r b1 b2 = wo_rel.max2 r c1 c2 \<and> b1 = c1 \<and> (b2,c2) \<in> r - Id"
-      hence "(a2,c2) \<in> r - Id"
-      using Case4 TransS trans_def[of "r - Id"] by blast
-      hence ?thesis using Case4 Case44 0 unfolding bsqr_def by auto
-     }
-     ultimately have ?thesis using 0 2 by auto
-    }
-    ultimately show ?thesis using 0 1 by auto
-  qed
-qed
-
-
-lemma bsqr_antisym:
-assumes "Well_order r"
-shows "antisym (bsqr r)"
-proof(unfold antisym_def, clarify)
-  (* Preliminary facts *)
-  have Well: "wo_rel r" using assms wo_rel_def by auto
-  hence Trans: "trans r" using wo_rel.TRANS by auto
-  have Anti: "antisym r" using wo_rel.ANTISYM Well by auto
-  hence TransS: "trans(r - Id)" using Trans by (simp add: trans_diff_Id)
-  hence IrrS: "\<forall>a b. \<not>((a,b) \<in> r - Id \<and> (b,a) \<in> r - Id)"
-  using Anti trans_def[of "r - Id"] antisym_def[of "r - Id"] by blast
-  (* Main proof *)
-  fix a1 a2 b1 b2
-  assume *: "((a1,a2),(b1,b2)) \<in> bsqr r" and **: "((b1,b2),(a1,a2)) \<in> bsqr r"
-  hence 0: "{a1,a2,b1,b2} \<le> Field r" unfolding bsqr_def by auto
-  have 1: "a1 = b1 \<and> a2 = b2 \<or> (wo_rel.max2 r a1 a2, wo_rel.max2 r b1 b2) \<in> r - Id \<or>
-           wo_rel.max2 r a1 a2 = wo_rel.max2 r b1 b2 \<and> (a1,b1) \<in> r - Id \<or>
-           wo_rel.max2 r a1 a2 = wo_rel.max2 r b1 b2 \<and> a1 = b1 \<and> (a2,b2) \<in> r - Id"
-  using * unfolding bsqr_def by auto
-  have 2: "b1 = a1 \<and> b2 = a2 \<or> (wo_rel.max2 r b1 b2, wo_rel.max2 r a1 a2) \<in> r - Id \<or>
-           wo_rel.max2 r b1 b2 = wo_rel.max2 r a1 a2 \<and> (b1,a1) \<in> r - Id \<or>
-           wo_rel.max2 r b1 b2 = wo_rel.max2 r a1 a2 \<and> b1 = a1 \<and> (b2,a2) \<in> r - Id"
-  using ** unfolding bsqr_def by auto
-  show "a1 = b1 \<and> a2 = b2"
-  proof-
-    {assume Case1: "(wo_rel.max2 r a1 a2, wo_rel.max2 r b1 b2) \<in> r - Id"
-     {assume Case11: "(wo_rel.max2 r b1 b2, wo_rel.max2 r a1 a2) \<in> r - Id"
-      hence False using Case1 IrrS by blast
-     }
-     moreover
-     {assume Case12_3: "wo_rel.max2 r b1 b2 = wo_rel.max2 r a1 a2"
-      hence False using Case1 by auto
-     }
-     ultimately have ?thesis using 0 2 by auto
-    }
-    moreover
-    {assume Case2: "wo_rel.max2 r a1 a2 = wo_rel.max2 r b1 b2 \<and> (a1,b1) \<in> r - Id"
-     {assume Case21: "(wo_rel.max2 r b1 b2, wo_rel.max2 r a1 a2) \<in> r - Id"
-       hence False using Case2 by auto
-     }
-     moreover
-     {assume Case22: "(b1,a1) \<in> r - Id"
-      hence False using Case2 IrrS by blast
-     }
-     moreover
-     {assume Case23: "b1 = a1"
-      hence False using Case2 by auto
-     }
-     ultimately have ?thesis using 0 2 by auto
-    }
-    moreover
-    {assume Case3: "wo_rel.max2 r a1 a2 = wo_rel.max2 r b1 b2 \<and> a1 = b1 \<and> (a2,b2) \<in> r - Id"
-     moreover
-     {assume Case31: "(wo_rel.max2 r b1 b2, wo_rel.max2 r a1 a2) \<in> r - Id"
-      hence False using Case3 by auto
-     }
-     moreover
-     {assume Case32: "(b1,a1) \<in> r - Id"
-      hence False using Case3 by auto
-     }
-     moreover
-     {assume Case33: "(b2,a2) \<in> r - Id"
-      hence False using Case3 IrrS by blast
-     }
-     ultimately have ?thesis using 0 2 by auto
-    }
-    ultimately show ?thesis using 0 1 by blast
-  qed
-qed
-
-
-lemma bsqr_Total:
-assumes "Well_order r"
-shows "Total(bsqr r)"
-proof-
-  (* Preliminary facts *)
-  have Well: "wo_rel r" using assms wo_rel_def by auto
-  hence Total: "\<forall>a \<in> Field r. \<forall>b \<in> Field r. (a,b) \<in> r \<or> (b,a) \<in> r"
-  using wo_rel.TOTALS by auto
-  (* Main proof *)
-  {fix a1 a2 b1 b2 assume "{(a1,a2), (b1,b2)} \<le> Field(bsqr r)"
-   hence 0: "a1 \<in> Field r \<and> a2 \<in> Field r \<and> b1 \<in> Field r \<and> b2 \<in> Field r"
-   using Field_bsqr by blast
-   have "((a1,a2) = (b1,b2) \<or> ((a1,a2),(b1,b2)) \<in> bsqr r \<or> ((b1,b2),(a1,a2)) \<in> bsqr r)"
-   proof(rule wo_rel.cases_Total[of r a1 a2], clarsimp simp add: Well, simp add: 0)
-       (* Why didn't clarsimp simp add: Well 0 do the same job? *)
-     assume Case1: "(a1,a2) \<in> r"
-     hence 1: "wo_rel.max2 r a1 a2 = a2"
-     using Well 0 by (simp add: wo_rel.max2_equals2)
-     show ?thesis
-     proof(rule wo_rel.cases_Total[of r b1 b2], clarsimp simp add: Well, simp add: 0)
-       assume Case11: "(b1,b2) \<in> r"
-       hence 2: "wo_rel.max2 r b1 b2 = b2"
-       using Well 0 by (simp add: wo_rel.max2_equals2)
-       show ?thesis
-       proof(rule wo_rel.cases_Total3[of r a2 b2], clarsimp simp add: Well, simp add: 0)
-         assume Case111: "(a2,b2) \<in> r - Id \<or> (b2,a2) \<in> r - Id"
-         thus ?thesis using 0 1 2 unfolding bsqr_def by auto
-       next
-         assume Case112: "a2 = b2"
-         show ?thesis
-         proof(rule wo_rel.cases_Total3[of r a1 b1], clarsimp simp add: Well, simp add: 0)
-           assume Case1121: "(a1,b1) \<in> r - Id \<or> (b1,a1) \<in> r - Id"
-           thus ?thesis using 0 1 2 Case112 unfolding bsqr_def by auto
-         next
-           assume Case1122: "a1 = b1"
-           thus ?thesis using Case112 by auto
-         qed
-       qed
-     next
-       assume Case12: "(b2,b1) \<in> r"
-       hence 3: "wo_rel.max2 r b1 b2 = b1" using Well 0 by (simp add: wo_rel.max2_equals1)
-       show ?thesis
-       proof(rule wo_rel.cases_Total3[of r a2 b1], clarsimp simp add: Well, simp add: 0)
-         assume Case121: "(a2,b1) \<in> r - Id \<or> (b1,a2) \<in> r - Id"
-         thus ?thesis using 0 1 3 unfolding bsqr_def by auto
-       next
-         assume Case122: "a2 = b1"
-         show ?thesis
-         proof(rule wo_rel.cases_Total3[of r a1 b1], clarsimp simp add: Well, simp add: 0)
-           assume Case1221: "(a1,b1) \<in> r - Id \<or> (b1,a1) \<in> r - Id"
-           thus ?thesis using 0 1 3 Case122 unfolding bsqr_def by auto
-         next
-           assume Case1222: "a1 = b1"
-           show ?thesis
-           proof(rule wo_rel.cases_Total3[of r a2 b2], clarsimp simp add: Well, simp add: 0)
-             assume Case12221: "(a2,b2) \<in> r - Id \<or> (b2,a2) \<in> r - Id"
-             thus ?thesis using 0 1 3 Case122 Case1222 unfolding bsqr_def by auto
-           next
-             assume Case12222: "a2 = b2"
-             thus ?thesis using Case122 Case1222 by auto
-           qed
-         qed
-       qed
-     qed
-   next
-     assume Case2: "(a2,a1) \<in> r"
-     hence 1: "wo_rel.max2 r a1 a2 = a1" using Well 0 by (simp add: wo_rel.max2_equals1)
-     show ?thesis
-     proof(rule wo_rel.cases_Total[of r b1 b2], clarsimp simp add: Well, simp add: 0)
-       assume Case21: "(b1,b2) \<in> r"
-       hence 2: "wo_rel.max2 r b1 b2 = b2" using Well 0 by (simp add: wo_rel.max2_equals2)
-       show ?thesis
-       proof(rule wo_rel.cases_Total3[of r a1 b2], clarsimp simp add: Well, simp add: 0)
-         assume Case211: "(a1,b2) \<in> r - Id \<or> (b2,a1) \<in> r - Id"
-         thus ?thesis using 0 1 2 unfolding bsqr_def by auto
-       next
-         assume Case212: "a1 = b2"
-         show ?thesis
-         proof(rule wo_rel.cases_Total3[of r a1 b1], clarsimp simp add: Well, simp add: 0)
-           assume Case2121: "(a1,b1) \<in> r - Id \<or> (b1,a1) \<in> r - Id"
-           thus ?thesis using 0 1 2 Case212 unfolding bsqr_def by auto
-         next
-           assume Case2122: "a1 = b1"
-           show ?thesis
-           proof(rule wo_rel.cases_Total3[of r a2 b2], clarsimp simp add: Well, simp add: 0)
-             assume Case21221: "(a2,b2) \<in> r - Id \<or> (b2,a2) \<in> r - Id"
-             thus ?thesis using 0 1 2 Case212 Case2122 unfolding bsqr_def by auto
-           next
-             assume Case21222: "a2 = b2"
-             thus ?thesis using Case2122 Case212 by auto
-           qed
-         qed
-       qed
-     next
-       assume Case22: "(b2,b1) \<in> r"
-       hence 3: "wo_rel.max2 r b1 b2 = b1"  using Well 0 by (simp add: wo_rel.max2_equals1)
-       show ?thesis
-       proof(rule wo_rel.cases_Total3[of r a1 b1], clarsimp simp add: Well, simp add: 0)
-         assume Case221: "(a1,b1) \<in> r - Id \<or> (b1,a1) \<in> r - Id"
-         thus ?thesis using 0 1 3 unfolding bsqr_def by auto
-       next
-         assume Case222: "a1 = b1"
-         show ?thesis
-         proof(rule wo_rel.cases_Total3[of r a2 b2], clarsimp simp add: Well, simp add: 0)
-           assume Case2221: "(a2,b2) \<in> r - Id \<or> (b2,a2) \<in> r - Id"
-           thus ?thesis using 0 1 3 Case222 unfolding bsqr_def by auto
-         next
-           assume Case2222: "a2 = b2"
-           thus ?thesis using Case222 by auto
-         qed
-       qed
-     qed
-   qed
-  }
-  thus ?thesis unfolding total_on_def by fast
-qed
-
-
-lemma bsqr_Linear_order:
-assumes "Well_order r"
-shows "Linear_order(bsqr r)"
-unfolding order_on_defs
-using assms bsqr_Refl bsqr_Trans bsqr_antisym bsqr_Total by blast
-
-
-lemma bsqr_Well_order:
-assumes "Well_order r"
-shows "Well_order(bsqr r)"
-using assms
-proof(simp add: bsqr_Linear_order Linear_order_Well_order_iff, intro allI impI)
-  have 0: "\<forall>A \<le> Field r. A \<noteq> {} \<longrightarrow> (\<exists>a \<in> A. \<forall>a' \<in> A. (a,a') \<in> r)"
-  using assms well_order_on_def Linear_order_Well_order_iff by blast
-  fix D assume *: "D \<le> Field (bsqr r)" and **: "D \<noteq> {}"
-  hence 1: "D \<le> Field r \<times> Field r" unfolding Field_bsqr by simp
-  (*  *)
-  obtain M where M_def: "M = {wo_rel.max2 r a1 a2| a1 a2. (a1,a2) \<in> D}" by blast
-  have "M \<noteq> {}" using 1 M_def ** by auto
-  moreover
-  have "M \<le> Field r" unfolding M_def
-  using 1 assms wo_rel_def[of r] wo_rel.max2_among[of r] by fastforce
-  ultimately obtain m where m_min: "m \<in> M \<and> (\<forall>a \<in> M. (m,a) \<in> r)"
-  using 0 by blast
-  (*  *)
-  obtain A1 where A1_def: "A1 = {a1. \<exists>a2. (a1,a2) \<in> D \<and> wo_rel.max2 r a1 a2 = m}" by blast
-  have "A1 \<le> Field r" unfolding A1_def using 1 by auto
-  moreover have "A1 \<noteq> {}" unfolding A1_def using m_min unfolding M_def by blast
-  ultimately obtain a1 where a1_min: "a1 \<in> A1 \<and> (\<forall>a \<in> A1. (a1,a) \<in> r)"
-  using 0 by blast
-  (*  *)
-  obtain A2 where A2_def: "A2 = {a2. (a1,a2) \<in> D \<and> wo_rel.max2 r a1 a2 = m}" by blast
-  have "A2 \<le> Field r" unfolding A2_def using 1 by auto
-  moreover have "A2 \<noteq> {}" unfolding A2_def
-  using m_min a1_min unfolding A1_def M_def by blast
-  ultimately obtain a2 where a2_min: "a2 \<in> A2 \<and> (\<forall>a \<in> A2. (a2,a) \<in> r)"
-  using 0 by blast
-  (*   *)
-  have 2: "wo_rel.max2 r a1 a2 = m"
-  using a1_min a2_min unfolding A1_def A2_def by auto
-  have 3: "(a1,a2) \<in> D" using a2_min unfolding A2_def by auto
-  (*  *)
-  moreover
-  {fix b1 b2 assume ***: "(b1,b2) \<in> D"
-   hence 4: "{a1,a2,b1,b2} \<le> Field r" using 1 3 by blast
-   have 5: "(wo_rel.max2 r a1 a2, wo_rel.max2 r b1 b2) \<in> r"
-   using *** a1_min a2_min m_min unfolding A1_def A2_def M_def by auto
-   have "((a1,a2),(b1,b2)) \<in> bsqr r"
-   proof(cases "wo_rel.max2 r a1 a2 = wo_rel.max2 r b1 b2")
-     assume Case1: "wo_rel.max2 r a1 a2 \<noteq> wo_rel.max2 r b1 b2"
-     thus ?thesis unfolding bsqr_def using 4 5 by auto
-   next
-     assume Case2: "wo_rel.max2 r a1 a2 = wo_rel.max2 r b1 b2"
-     hence "b1 \<in> A1" unfolding A1_def using 2 *** by auto
-     hence 6: "(a1,b1) \<in> r" using a1_min by auto
-     show ?thesis
-     proof(cases "a1 = b1")
-       assume Case21: "a1 \<noteq> b1"
-       thus ?thesis unfolding bsqr_def using 4 Case2 6 by auto
-     next
-       assume Case22: "a1 = b1"
-       hence "b2 \<in> A2" unfolding A2_def using 2 *** Case2 by auto
-       hence 7: "(a2,b2) \<in> r" using a2_min by auto
-       thus ?thesis unfolding bsqr_def using 4 7 Case2 Case22 by auto
-     qed
-   qed
-  }
-  (*  *)
-  ultimately show "\<exists>d \<in> D. \<forall>d' \<in> D. (d,d') \<in> bsqr r" by fastforce
-qed
-
-
-lemma bsqr_max2:
-assumes WELL: "Well_order r" and LEQ: "((a1,a2),(b1,b2)) \<in> bsqr r"
-shows "(wo_rel.max2 r a1 a2, wo_rel.max2 r b1 b2) \<in> r"
-proof-
-  have "{(a1,a2),(b1,b2)} \<le> Field(bsqr r)"
-  using LEQ unfolding Field_def by auto
-  hence "{a1,a2,b1,b2} \<le> Field r" unfolding Field_bsqr by auto
-  hence "{wo_rel.max2 r a1 a2, wo_rel.max2 r b1 b2} \<le> Field r"
-  using WELL wo_rel_def[of r] wo_rel.max2_among[of r] by fastforce
-  moreover have "(wo_rel.max2 r a1 a2, wo_rel.max2 r b1 b2) \<in> r \<or> wo_rel.max2 r a1 a2 = wo_rel.max2 r b1 b2"
-  using LEQ unfolding bsqr_def by auto
-  ultimately show ?thesis using WELL unfolding order_on_defs refl_on_def by auto
-qed
-
-
-lemma bsqr_ofilter:
-assumes WELL: "Well_order r" and
-        OF: "wo_rel.ofilter (bsqr r) D" and SUB: "D < Field r \<times> Field r" and
-        NE: "\<not> (\<exists>a. Field r = under r a)"
-shows "\<exists>A. wo_rel.ofilter r A \<and> A < Field r \<and> D \<le> A \<times> A"
-proof-
-  let ?r' = "bsqr r"
-  have Well: "wo_rel r" using WELL wo_rel_def by blast
-  hence Trans: "trans r" using wo_rel.TRANS by blast
-  have Well': "Well_order ?r' \<and> wo_rel ?r'"
-  using WELL bsqr_Well_order wo_rel_def by blast
-  (*  *)
-  have "D < Field ?r'" unfolding Field_bsqr using SUB .
-  with OF obtain a1 and a2 where
-  "(a1,a2) \<in> Field ?r'" and 1: "D = underS ?r' (a1,a2)"
-  using Well' wo_rel.ofilter_underS_Field[of ?r' D] by auto
-  hence 2: "{a1,a2} \<le> Field r" unfolding Field_bsqr by auto
-  let ?m = "wo_rel.max2 r a1 a2"
-  have "D \<le> (under r ?m) \<times> (under r ?m)"
-  proof(unfold 1)
-    {fix b1 b2
-     let ?n = "wo_rel.max2 r b1 b2"
-     assume "(b1,b2) \<in> underS ?r' (a1,a2)"
-     hence 3: "((b1,b2),(a1,a2)) \<in> ?r'"
-     unfolding underS_def by blast
-     hence "(?n,?m) \<in> r" using WELL by (simp add: bsqr_max2)
-     moreover
-     {have "(b1,b2) \<in> Field ?r'" using 3 unfolding Field_def by auto
-      hence "{b1,b2} \<le> Field r" unfolding Field_bsqr by auto
-      hence "(b1,?n) \<in> r \<and> (b2,?n) \<in> r"
-      using Well by (simp add: wo_rel.max2_greater)
-     }
-     ultimately have "(b1,?m) \<in> r \<and> (b2,?m) \<in> r"
-     using Trans trans_def[of r] by blast
-     hence "(b1,b2) \<in> (under r ?m) \<times> (under r ?m)" unfolding under_def by simp}
-     thus "underS ?r' (a1,a2) \<le> (under r ?m) \<times> (under r ?m)" by auto
-  qed
-  moreover have "wo_rel.ofilter r (under r ?m)"
-  using Well by (simp add: wo_rel.under_ofilter)
-  moreover have "under r ?m < Field r"
-  using NE under_Field[of r ?m] by blast
-  ultimately show ?thesis by blast
-qed
-
-definition Func where
-"Func A B = {f . (\<forall> a \<in> A. f a \<in> B) \<and> (\<forall> a. a \<notin> A \<longrightarrow> f a = undefined)}"
-
-lemma Func_empty:
-"Func {} B = {\<lambda>x. undefined}"
-unfolding Func_def by auto
-
-lemma Func_elim:
-assumes "g \<in> Func A B" and "a \<in> A"
-shows "\<exists> b. b \<in> B \<and> g a = b"
-using assms unfolding Func_def by (cases "g a = undefined") auto
-
-definition curr where
-"curr A f \<equiv> \<lambda> a. if a \<in> A then \<lambda>b. f (a,b) else undefined"
-
-lemma curr_in:
-assumes f: "f \<in> Func (A <*> B) C"
-shows "curr A f \<in> Func A (Func B C)"
-using assms unfolding curr_def Func_def by auto
-
-lemma curr_inj:
-assumes "f1 \<in> Func (A <*> B) C" and "f2 \<in> Func (A <*> B) C"
-shows "curr A f1 = curr A f2 \<longleftrightarrow> f1 = f2"
-proof safe
-  assume c: "curr A f1 = curr A f2"
-  show "f1 = f2"
-  proof (rule ext, clarify)
-    fix a b show "f1 (a, b) = f2 (a, b)"
-    proof (cases "(a,b) \<in> A <*> B")
-      case False
-      thus ?thesis using assms unfolding Func_def by auto
-    next
-      case True hence a: "a \<in> A" and b: "b \<in> B" by auto
-      thus ?thesis
-      using c unfolding curr_def fun_eq_iff by(elim allE[of _ a]) simp
-    qed
-  qed
-qed
-
-lemma curr_surj:
-assumes "g \<in> Func A (Func B C)"
-shows "\<exists> f \<in> Func (A <*> B) C. curr A f = g"
-proof
-  let ?f = "\<lambda> ab. if fst ab \<in> A \<and> snd ab \<in> B then g (fst ab) (snd ab) else undefined"
-  show "curr A ?f = g"
-  proof (rule ext)
-    fix a show "curr A ?f a = g a"
-    proof (cases "a \<in> A")
-      case False
-      hence "g a = undefined" using assms unfolding Func_def by auto
-      thus ?thesis unfolding curr_def using False by simp
-    next
-      case True
-      obtain g1 where "g1 \<in> Func B C" and "g a = g1"
-      using assms using Func_elim[OF assms True] by blast
-      thus ?thesis using True unfolding Func_def curr_def by auto
-    qed
-  qed
-  show "?f \<in> Func (A <*> B) C" using assms unfolding Func_def mem_Collect_eq by auto
-qed
-
-lemma bij_betw_curr:
-"bij_betw (curr A) (Func (A <*> B) C) (Func A (Func B C))"
-unfolding bij_betw_def inj_on_def image_def
-apply (intro impI conjI ballI)
-apply (erule curr_inj[THEN iffD1], assumption+)
-apply auto
-apply (erule curr_in)
-using curr_surj by blast
-
-definition Func_map where
-"Func_map B2 f1 f2 g b2 \<equiv> if b2 \<in> B2 then f1 (g (f2 b2)) else undefined"
-
-lemma Func_map:
-assumes g: "g \<in> Func A2 A1" and f1: "f1 ` A1 \<subseteq> B1" and f2: "f2 ` B2 \<subseteq> A2"
-shows "Func_map B2 f1 f2 g \<in> Func B2 B1"
-using assms unfolding Func_def Func_map_def mem_Collect_eq by auto
-
-lemma Func_non_emp:
-assumes "B \<noteq> {}"
-shows "Func A B \<noteq> {}"
-proof-
-  obtain b where b: "b \<in> B" using assms by auto
-  hence "(\<lambda> a. if a \<in> A then b else undefined) \<in> Func A B" unfolding Func_def by auto
-  thus ?thesis by blast
-qed
-
-lemma Func_is_emp:
-"Func A B = {} \<longleftrightarrow> A \<noteq> {} \<and> B = {}" (is "?L \<longleftrightarrow> ?R")
-proof
-  assume L: ?L
-  moreover {assume "A = {}" hence False using L Func_empty by auto}
-  moreover {assume "B \<noteq> {}" hence False using L Func_non_emp by metis}
-  ultimately show ?R by blast
-next
-  assume R: ?R
-  moreover
-  {fix f assume "f \<in> Func A B"
-   moreover obtain a where "a \<in> A" using R by blast
-   ultimately obtain b where "b \<in> B" unfolding Func_def by blast
-   with R have False by blast
-  }
-  thus ?L by blast
-qed
-
-lemma Func_map_surj:
-assumes B1: "f1 ` A1 = B1" and A2: "inj_on f2 B2" "f2 ` B2 \<subseteq> A2"
-and B2A2: "B2 = {} \<Longrightarrow> A2 = {}"
-shows "Func B2 B1 = Func_map B2 f1 f2 ` Func A2 A1"
-proof(cases "B2 = {}")
-  case True
-  thus ?thesis using B2A2 by (auto simp: Func_empty Func_map_def)
-next
-  case False note B2 = False
-  show ?thesis
-  proof safe
-    fix h assume h: "h \<in> Func B2 B1"
-    def j1 \<equiv> "inv_into A1 f1"
-    have "\<forall> a2 \<in> f2 ` B2. \<exists> b2. b2 \<in> B2 \<and> f2 b2 = a2" by blast
-    then obtain k where k: "\<forall> a2 \<in> f2 ` B2. k a2 \<in> B2 \<and> f2 (k a2) = a2" by metis
-    {fix b2 assume b2: "b2 \<in> B2"
-     hence "f2 (k (f2 b2)) = f2 b2" using k A2(2) by auto
-     moreover have "k (f2 b2) \<in> B2" using b2 A2(2) k by auto
-     ultimately have "k (f2 b2) = b2" using b2 A2(1) unfolding inj_on_def by blast
-    } note kk = this
-    obtain b22 where b22: "b22 \<in> B2" using B2 by auto
-    def j2 \<equiv> "\<lambda> a2. if a2 \<in> f2 ` B2 then k a2 else b22"
-    have j2A2: "j2 ` A2 \<subseteq> B2" unfolding j2_def using k b22 by auto
-    have j2: "\<And> b2. b2 \<in> B2 \<Longrightarrow> j2 (f2 b2) = b2"
-    using kk unfolding j2_def by auto
-    def g \<equiv> "Func_map A2 j1 j2 h"
-    have "Func_map B2 f1 f2 g = h"
-    proof (rule ext)
-      fix b2 show "Func_map B2 f1 f2 g b2 = h b2"
-      proof(cases "b2 \<in> B2")
-        case True
-        show ?thesis
-        proof (cases "h b2 = undefined")
-          case True
-          hence b1: "h b2 \<in> f1 ` A1" using h `b2 \<in> B2` unfolding B1 Func_def by auto
-          show ?thesis using A2 f_inv_into_f[OF b1]
-            unfolding True g_def Func_map_def j1_def j2[OF `b2 \<in> B2`] by auto
-        qed(insert A2 True j2[OF True] h B1, unfold j1_def g_def Func_def Func_map_def,
-          auto intro: f_inv_into_f)
-      qed(insert h, unfold Func_def Func_map_def, auto)
-    qed
-    moreover have "g \<in> Func A2 A1" unfolding g_def apply(rule Func_map[OF h])
-    using inv_into_into j2A2 B1 A2 inv_into_into
-    unfolding j1_def image_def by fast+
-    ultimately show "h \<in> Func_map B2 f1 f2 ` Func A2 A1"
-    unfolding Func_map_def[abs_def] unfolding image_def by auto
-  qed(insert B1 Func_map[OF _ _ A2(2)], auto)
-qed
-
-end
--- a/src/HOL/Cardinals/Wellorder_Embedding_FP.thy	Mon Jan 20 16:14:19 2014 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1145 +0,0 @@
-(*  Title:      HOL/Cardinals/Wellorder_Embedding_FP.thy
-    Author:     Andrei Popescu, TU Muenchen
-    Copyright   2012
-
-Well-order embeddings (FP).
-*)
-
-header {* Well-Order Embeddings (FP) *}
-
-theory Wellorder_Embedding_FP
-imports Zorn Wellorder_Relation_FP
-begin
-
-
-text{* In this section, we introduce well-order {\em embeddings} and {\em isomorphisms} and
-prove their basic properties.  The notion of embedding is considered from the point
-of view of the theory of ordinals, and therefore requires the source to be injected
-as an {\em initial segment} (i.e., {\em order filter}) of the target.  A main result
-of this section is the existence of embeddings (in one direction or another) between
-any two well-orders, having as a consequence the fact that, given any two sets on
-any two types, one is smaller than (i.e., can be injected into) the other. *}
-
-
-subsection {* Auxiliaries *}
-
-lemma UNION_inj_on_ofilter:
-assumes WELL: "Well_order r" and
-        OF: "\<And> i. i \<in> I \<Longrightarrow> wo_rel.ofilter r (A i)" and
-       INJ: "\<And> i. i \<in> I \<Longrightarrow> inj_on f (A i)"
-shows "inj_on f (\<Union> i \<in> I. A i)"
-proof-
-  have "wo_rel r" using WELL by (simp add: wo_rel_def)
-  hence "\<And> i j. \<lbrakk>i \<in> I; j \<in> I\<rbrakk> \<Longrightarrow> A i <= A j \<or> A j <= A i"
-  using wo_rel.ofilter_linord[of r] OF by blast
-  with WELL INJ show ?thesis
-  by (auto simp add: inj_on_UNION_chain)
-qed
-
-
-lemma under_underS_bij_betw:
-assumes WELL: "Well_order r" and WELL': "Well_order r'" and
-        IN: "a \<in> Field r" and IN': "f a \<in> Field r'" and
-        BIJ: "bij_betw f (underS r a) (underS r' (f a))"
-shows "bij_betw f (under r a) (under r' (f a))"
-proof-
-  have "a \<notin> underS r a \<and> f a \<notin> underS r' (f a)"
-  unfolding underS_def by auto
-  moreover
-  {have "Refl r \<and> Refl r'" using WELL WELL'
-   by (auto simp add: order_on_defs)
-   hence "under r a = underS r a \<union> {a} \<and>
-          under r' (f a) = underS r' (f a) \<union> {f a}"
-   using IN IN' by(auto simp add: Refl_under_underS)
-  }
-  ultimately show ?thesis
-  using BIJ notIn_Un_bij_betw[of a "underS r a" f "underS r' (f a)"] by auto
-qed
-
-
-
-subsection {* (Well-order) embeddings, strict embeddings, isomorphisms and order-compatible
-functions  *}
-
-
-text{* Standardly, a function is an embedding of a well-order in another if it injectively and
-order-compatibly maps the former into an order filter of the latter.
-Here we opt for a more succinct definition (operator @{text "embed"}),
-asking that, for any element in the source, the function should be a bijection
-between the set of strict lower bounds of that element
-and the set of strict lower bounds of its image.  (Later we prove equivalence with
-the standard definition -- lemma @{text "embed_iff_compat_inj_on_ofilter"}.)
-A {\em strict embedding} (operator @{text "embedS"})  is a non-bijective embedding
-and an isomorphism (operator @{text "iso"}) is a bijective embedding.   *}
-
-
-definition embed :: "'a rel \<Rightarrow> 'a' rel \<Rightarrow> ('a \<Rightarrow> 'a') \<Rightarrow> bool"
-where
-"embed r r' f \<equiv> \<forall>a \<in> Field r. bij_betw f (under r a) (under r' (f a))"
-
-
-lemmas embed_defs = embed_def embed_def[abs_def]
-
-
-text {* Strict embeddings: *}
-
-definition embedS :: "'a rel \<Rightarrow> 'a' rel \<Rightarrow> ('a \<Rightarrow> 'a') \<Rightarrow> bool"
-where
-"embedS r r' f \<equiv> embed r r' f \<and> \<not> bij_betw f (Field r) (Field r')"
-
-
-lemmas embedS_defs = embedS_def embedS_def[abs_def]
-
-
-definition iso :: "'a rel \<Rightarrow> 'a' rel \<Rightarrow> ('a \<Rightarrow> 'a') \<Rightarrow> bool"
-where
-"iso r r' f \<equiv> embed r r' f \<and> bij_betw f (Field r) (Field r')"
-
-
-lemmas iso_defs = iso_def iso_def[abs_def]
-
-
-definition compat :: "'a rel \<Rightarrow> 'a' rel \<Rightarrow> ('a \<Rightarrow> 'a') \<Rightarrow> bool"
-where
-"compat r r' f \<equiv> \<forall>a b. (a,b) \<in> r \<longrightarrow> (f a, f b) \<in> r'"
-
-
-lemma compat_wf:
-assumes CMP: "compat r r' f" and WF: "wf r'"
-shows "wf r"
-proof-
-  have "r \<le> inv_image r' f"
-  unfolding inv_image_def using CMP
-  by (auto simp add: compat_def)
-  with WF show ?thesis
-  using wf_inv_image[of r' f] wf_subset[of "inv_image r' f"] by auto
-qed
-
-
-lemma id_embed: "embed r r id"
-by(auto simp add: id_def embed_def bij_betw_def)
-
-
-lemma id_iso: "iso r r id"
-by(auto simp add: id_def embed_def iso_def bij_betw_def)
-
-
-lemma embed_in_Field:
-assumes WELL: "Well_order r" and
-        EMB: "embed r r' f" and IN: "a \<in> Field r"
-shows "f a \<in> Field r'"
-proof-
-  have Well: "wo_rel r"
-  using WELL by (auto simp add: wo_rel_def)
-  hence 1: "Refl r"
-  by (auto simp add: wo_rel.REFL)
-  hence "a \<in> under r a" using IN Refl_under_in by fastforce
-  hence "f a \<in> under r' (f a)"
-  using EMB IN by (auto simp add: embed_def bij_betw_def)
-  thus ?thesis unfolding Field_def
-  by (auto simp: under_def)
-qed
-
-
-lemma comp_embed:
-assumes WELL: "Well_order r" and
-        EMB: "embed r r' f" and EMB': "embed r' r'' f'"
-shows "embed r r'' (f' o f)"
-proof(unfold embed_def, auto)
-  fix a assume *: "a \<in> Field r"
-  hence "bij_betw f (under r a) (under r' (f a))"
-  using embed_def[of r] EMB by auto
-  moreover
-  {have "f a \<in> Field r'"
-   using EMB WELL * by (auto simp add: embed_in_Field)
-   hence "bij_betw f' (under r' (f a)) (under r'' (f' (f a)))"
-   using embed_def[of r'] EMB' by auto
-  }
-  ultimately
-  show "bij_betw (f' \<circ> f) (under r a) (under r'' (f'(f a)))"
-  by(auto simp add: bij_betw_trans)
-qed
-
-
-lemma comp_iso:
-assumes WELL: "Well_order r" and
-        EMB: "iso r r' f" and EMB': "iso r' r'' f'"
-shows "iso r r'' (f' o f)"
-using assms unfolding iso_def
-by (auto simp add: comp_embed bij_betw_trans)
-
-
-text{* That @{text "embedS"} is also preserved by function composition shall be proved only later.  *}
-
-
-lemma embed_Field:
-"\<lbrakk>Well_order r; embed r r' f\<rbrakk> \<Longrightarrow> f`(Field r) \<le> Field r'"
-by (auto simp add: embed_in_Field)
-
-
-lemma embed_preserves_ofilter:
-assumes WELL: "Well_order r" and WELL': "Well_order r'" and
-        EMB: "embed r r' f" and OF: "wo_rel.ofilter r A"
-shows "wo_rel.ofilter r' (f`A)"
-proof-
-  (* Preliminary facts *)
-  from WELL have Well: "wo_rel r" unfolding wo_rel_def .
-  from WELL' have Well': "wo_rel r'" unfolding wo_rel_def .
-  from OF have 0: "A \<le> Field r" by(auto simp add: Well wo_rel.ofilter_def)
-  (* Main proof *)
-  show ?thesis  using Well' WELL EMB 0 embed_Field[of r r' f]
-  proof(unfold wo_rel.ofilter_def, auto simp add: image_def)
-    fix a b'
-    assume *: "a \<in> A" and **: "b' \<in> under r' (f a)"
-    hence "a \<in> Field r" using 0 by auto
-    hence "bij_betw f (under r a) (under r' (f a))"
-    using * EMB by (auto simp add: embed_def)
-    hence "f`(under r a) = under r' (f a)"
-    by (simp add: bij_betw_def)
-    with ** image_def[of f "under r a"] obtain b where
-    1: "b \<in> under r a \<and> b' = f b" by blast
-    hence "b \<in> A" using Well * OF
-    by (auto simp add: wo_rel.ofilter_def)
-    with 1 show "\<exists>b \<in> A. b' = f b" by blast
-  qed
-qed
-
-
-lemma embed_Field_ofilter:
-assumes WELL: "Well_order r" and WELL': "Well_order r'" and
-        EMB: "embed r r' f"
-shows "wo_rel.ofilter r' (f`(Field r))"
-proof-
-  have "wo_rel.ofilter r (Field r)"
-  using WELL by (auto simp add: wo_rel_def wo_rel.Field_ofilter)
-  with WELL WELL' EMB
-  show ?thesis by (auto simp add: embed_preserves_ofilter)
-qed
-
-
-lemma embed_compat:
-assumes EMB: "embed r r' f"
-shows "compat r r' f"
-proof(unfold compat_def, clarify)
-  fix a b
-  assume *: "(a,b) \<in> r"
-  hence 1: "b \<in> Field r" using Field_def[of r] by blast
-  have "a \<in> under r b"
-  using * under_def[of r] by simp
-  hence "f a \<in> under r' (f b)"
-  using EMB embed_def[of r r' f]
-        bij_betw_def[of f "under r b" "under r' (f b)"]
-        image_def[of f "under r b"] 1 by auto
-  thus "(f a, f b) \<in> r'"
-  by (auto simp add: under_def)
-qed
-
-
-lemma embed_inj_on:
-assumes WELL: "Well_order r" and EMB: "embed r r' f"
-shows "inj_on f (Field r)"
-proof(unfold inj_on_def, clarify)
-  (* Preliminary facts *)
-  from WELL have Well: "wo_rel r" unfolding wo_rel_def .
-  with wo_rel.TOTAL[of r]
-  have Total: "Total r" by simp
-  from Well wo_rel.REFL[of r]
-  have Refl: "Refl r" by simp
-  (* Main proof *)
-  fix a b
-  assume *: "a \<in> Field r" and **: "b \<in> Field r" and
-         ***: "f a = f b"
-  hence 1: "a \<in> Field r \<and> b \<in> Field r"
-  unfolding Field_def by auto
-  {assume "(a,b) \<in> r"
-   hence "a \<in> under r b \<and> b \<in> under r b"
-   using Refl by(auto simp add: under_def refl_on_def)
-   hence "a = b"
-   using EMB 1 ***
-   by (auto simp add: embed_def bij_betw_def inj_on_def)
-  }
-  moreover
-  {assume "(b,a) \<in> r"
-   hence "a \<in> under r a \<and> b \<in> under r a"
-   using Refl by(auto simp add: under_def refl_on_def)
-   hence "a = b"
-   using EMB 1 ***
-   by (auto simp add: embed_def bij_betw_def inj_on_def)
-  }
-  ultimately
-  show "a = b" using Total 1
-  by (auto simp add: total_on_def)
-qed
-
-
-lemma embed_underS:
-assumes WELL: "Well_order r" and WELL': "Well_order r'" and
-        EMB: "embed r r' f" and IN: "a \<in> Field r"
-shows "bij_betw f (underS r a) (underS r' (f a))"
-proof-
-  have "bij_betw f (under r a) (under r' (f a))"
-  using assms by (auto simp add: embed_def)
-  moreover
-  {have "f a \<in> Field r'" using assms  embed_Field[of r r' f] by auto
-   hence "under r a = underS r a \<union> {a} \<and>
-          under r' (f a) = underS r' (f a) \<union> {f a}"
-   using assms by (auto simp add: order_on_defs Refl_under_underS)
-  }
-  moreover
-  {have "a \<notin> underS r a \<and> f a \<notin> underS r' (f a)"
-   unfolding underS_def by blast
-  }
-  ultimately show ?thesis
-  by (auto simp add: notIn_Un_bij_betw3)
-qed
-
-
-lemma embed_iff_compat_inj_on_ofilter:
-assumes WELL: "Well_order r" and WELL': "Well_order r'"
-shows "embed r r' f = (compat r r' f \<and> inj_on f (Field r) \<and> wo_rel.ofilter r' (f`(Field r)))"
-using assms
-proof(auto simp add: embed_compat embed_inj_on embed_Field_ofilter,
-      unfold embed_def, auto) (* get rid of one implication *)
-  fix a
-  assume *: "inj_on f (Field r)" and
-         **: "compat r r' f" and
-         ***: "wo_rel.ofilter r' (f`(Field r))" and
-         ****: "a \<in> Field r"
-  (* Preliminary facts *)
-  have Well: "wo_rel r"
-  using WELL wo_rel_def[of r] by simp
-  hence Refl: "Refl r"
-  using wo_rel.REFL[of r] by simp
-  have Total: "Total r"
-  using Well wo_rel.TOTAL[of r] by simp
-  have Well': "wo_rel r'"
-  using WELL' wo_rel_def[of r'] by simp
-  hence Antisym': "antisym r'"
-  using wo_rel.ANTISYM[of r'] by simp
-  have "(a,a) \<in> r"
-  using **** Well wo_rel.REFL[of r]
-        refl_on_def[of _ r] by auto
-  hence "(f a, f a) \<in> r'"
-  using ** by(auto simp add: compat_def)
-  hence 0: "f a \<in> Field r'"
-  unfolding Field_def by auto
-  have "f a \<in> f`(Field r)"
-  using **** by auto
-  hence 2: "under r' (f a) \<le> f`(Field r)"
-  using Well' *** wo_rel.ofilter_def[of r' "f`(Field r)"] by fastforce
-  (* Main proof *)
-  show "bij_betw f (under r a) (under r' (f a))"
-  proof(unfold bij_betw_def, auto)
-    show  "inj_on f (under r a)"
-    using * by (metis (no_types) under_Field subset_inj_on)
-  next
-    fix b assume "b \<in> under r a"
-    thus "f b \<in> under r' (f a)"
-    unfolding under_def using **
-    by (auto simp add: compat_def)
-  next
-    fix b' assume *****: "b' \<in> under r' (f a)"
-    hence "b' \<in> f`(Field r)"
-    using 2 by auto
-    with Field_def[of r] obtain b where
-    3: "b \<in> Field r" and 4: "b' = f b" by auto
-    have "(b,a): r"
-    proof-
-      {assume "(a,b) \<in> r"
-       with ** 4 have "(f a, b'): r'"
-       by (auto simp add: compat_def)
-       with ***** Antisym' have "f a = b'"
-       by(auto simp add: under_def antisym_def)
-       with 3 **** 4 * have "a = b"
-       by(auto simp add: inj_on_def)
-      }
-      moreover
-      {assume "a = b"
-       hence "(b,a) \<in> r" using Refl **** 3
-       by (auto simp add: refl_on_def)
-      }
-      ultimately
-      show ?thesis using Total **** 3 by (fastforce simp add: total_on_def)
-    qed
-    with 4 show  "b' \<in> f`(under r a)"
-    unfolding under_def by auto
-  qed
-qed
-
-
-lemma inv_into_ofilter_embed:
-assumes WELL: "Well_order r" and OF: "wo_rel.ofilter r A" and
-        BIJ: "\<forall>b \<in> A. bij_betw f (under r b) (under r' (f b))" and
-        IMAGE: "f ` A = Field r'"
-shows "embed r' r (inv_into A f)"
-proof-
-  (* Preliminary facts *)
-  have Well: "wo_rel r"
-  using WELL wo_rel_def[of r] by simp
-  have Refl: "Refl r"
-  using Well wo_rel.REFL[of r] by simp
-  have Total: "Total r"
-  using Well wo_rel.TOTAL[of r] by simp
-  (* Main proof *)
-  have 1: "bij_betw f A (Field r')"
-  proof(unfold bij_betw_def inj_on_def, auto simp add: IMAGE)
-    fix b1 b2
-    assume *: "b1 \<in> A" and **: "b2 \<in> A" and
-           ***: "f b1 = f b2"
-    have 11: "b1 \<in> Field r \<and> b2 \<in> Field r"
-    using * ** Well OF by (auto simp add: wo_rel.ofilter_def)
-    moreover
-    {assume "(b1,b2) \<in> r"
-     hence "b1 \<in> under r b2 \<and> b2 \<in> under r b2"
-     unfolding under_def using 11 Refl
-     by (auto simp add: refl_on_def)
-     hence "b1 = b2" using BIJ * ** ***
-     by (simp add: bij_betw_def inj_on_def)
-    }
-    moreover
-     {assume "(b2,b1) \<in> r"
-     hence "b1 \<in> under r b1 \<and> b2 \<in> under r b1"
-     unfolding under_def using 11 Refl
-     by (auto simp add: refl_on_def)
-     hence "b1 = b2" using BIJ * ** ***
-     by (simp add: bij_betw_def inj_on_def)
-    }
-    ultimately
-    show "b1 = b2"
-    using Total by (auto simp add: total_on_def)
-  qed
-  (*  *)
-  let ?f' = "(inv_into A f)"
-  (*  *)
-  have 2: "\<forall>b \<in> A. bij_betw ?f' (under r' (f b)) (under r b)"
-  proof(clarify)
-    fix b assume *: "b \<in> A"
-    hence "under r b \<le> A"
-    using Well OF by(auto simp add: wo_rel.ofilter_def)
-    moreover
-    have "f ` (under r b) = under r' (f b)"
-    using * BIJ by (auto simp add: bij_betw_def)
-    ultimately
-    show "bij_betw ?f' (under r' (f b)) (under r b)"
-    using 1 by (auto simp add: bij_betw_inv_into_subset)
-  qed
-  (*  *)
-  have 3: "\<forall>b' \<in> Field r'. bij_betw ?f' (under r' b') (under r (?f' b'))"
-  proof(clarify)
-    fix b' assume *: "b' \<in> Field r'"
-    have "b' = f (?f' b')" using * 1
-    by (auto simp add: bij_betw_inv_into_right)
-    moreover
-    {obtain b where 31: "b \<in> A" and "f b = b'" using IMAGE * by force
-     hence "?f' b' = b" using 1 by (auto simp add: bij_betw_inv_into_left)
-     with 31 have "?f' b' \<in> A" by auto
-    }
-    ultimately
-    show  "bij_betw ?f' (under r' b') (under r (?f' b'))"
-    using 2 by auto
-  qed
-  (*  *)
-  thus ?thesis unfolding embed_def .
-qed
-
-
-lemma inv_into_underS_embed:
-assumes WELL: "Well_order r" and
-        BIJ: "\<forall>b \<in> underS r a. bij_betw f (under r b) (under r' (f b))" and
-        IN: "a \<in> Field r" and
-        IMAGE: "f ` (underS r a) = Field r'"
-shows "embed r' r (inv_into (underS r a) f)"
-using assms
-by(auto simp add: wo_rel_def wo_rel.underS_ofilter inv_into_ofilter_embed)
-
-
-lemma inv_into_Field_embed:
-assumes WELL: "Well_order r" and EMB: "embed r r' f" and
-        IMAGE: "Field r' \<le> f ` (Field r)"
-shows "embed r' r (inv_into (Field r) f)"
-proof-
-  have "(\<forall>b \<in> Field r. bij_betw f (under r b) (under r' (f b)))"
-  using EMB by (auto simp add: embed_def)
-  moreover
-  have "f ` (Field r) \<le> Field r'"
-  using EMB WELL by (auto simp add: embed_Field)
-  ultimately
-  show ?thesis using assms
-  by(auto simp add: wo_rel_def wo_rel.Field_ofilter inv_into_ofilter_embed)
-qed
-
-
-lemma inv_into_Field_embed_bij_betw:
-assumes WELL: "Well_order r" and
-        EMB: "embed r r' f" and BIJ: "bij_betw f (Field r) (Field r')"
-shows "embed r' r (inv_into (Field r) f)"
-proof-
-  have "Field r' \<le> f ` (Field r)"
-  using BIJ by (auto simp add: bij_betw_def)
-  thus ?thesis using assms
-  by(auto simp add: inv_into_Field_embed)
-qed
-
-
-
-
-
-subsection {* Given any two well-orders, one can be embedded in the other *}
-
-
-text{* Here is an overview of the proof of of this fact, stated in theorem
-@{text "wellorders_totally_ordered"}:
-
-   Fix the well-orders @{text "r::'a rel"} and @{text "r'::'a' rel"}.
-   Attempt to define an embedding @{text "f::'a \<Rightarrow> 'a'"} from @{text "r"} to @{text "r'"} in the
-   natural way by well-order recursion ("hoping" that @{text "Field r"} turns out to be smaller
-   than @{text "Field r'"}), but also record, at the recursive step, in a function
-   @{text "g::'a \<Rightarrow> bool"}, the extra information of whether @{text "Field r'"}
-   gets exhausted or not.
-
-   If @{text "Field r'"} does not get exhausted, then @{text "Field r"} is indeed smaller
-   and @{text "f"} is the desired embedding from @{text "r"} to @{text "r'"}
-   (lemma @{text "wellorders_totally_ordered_aux"}).
-
-   Otherwise, it means that @{text "Field r'"} is the smaller one, and the inverse of
-   (the "good" segment of) @{text "f"} is the desired embedding from @{text "r'"} to @{text "r"}
-   (lemma @{text "wellorders_totally_ordered_aux2"}).
-*}
-
-
-lemma wellorders_totally_ordered_aux:
-fixes r ::"'a rel"  and r'::"'a' rel" and
-      f :: "'a \<Rightarrow> 'a'" and a::'a
-assumes WELL: "Well_order r" and WELL': "Well_order r'" and IN: "a \<in> Field r" and
-        IH: "\<forall>b \<in> underS r a. bij_betw f (under r b) (under r' (f b))" and
-        NOT: "f ` (underS r a) \<noteq> Field r'" and SUC: "f a = wo_rel.suc r' (f`(underS r a))"
-shows "bij_betw f (under r a) (under r' (f a))"
-proof-
-  (* Preliminary facts *)
-  have Well: "wo_rel r" using WELL unfolding wo_rel_def .
-  hence Refl: "Refl r" using wo_rel.REFL[of r] by auto
-  have Trans: "trans r" using Well wo_rel.TRANS[of r] by auto
-  have Well': "wo_rel r'" using WELL' unfolding wo_rel_def .
-  have OF: "wo_rel.ofilter r (underS r a)"
-  by (auto simp add: Well wo_rel.underS_ofilter)
-  hence UN: "underS r a = (\<Union>  b \<in> underS r a. under r b)"
-  using Well wo_rel.ofilter_under_UNION[of r "underS r a"] by blast
-  (* Gather facts about elements of underS r a *)
-  {fix b assume *: "b \<in> underS r a"
-   hence t0: "(b,a) \<in> r \<and> b \<noteq> a" unfolding underS_def by auto
-   have t1: "b \<in> Field r"
-   using * underS_Field[of r a] by auto
-   have t2: "f`(under r b) = under r' (f b)"
-   using IH * by (auto simp add: bij_betw_def)
-   hence t3: "wo_rel.ofilter r' (f`(under r b))"
-   using Well' by (auto simp add: wo_rel.under_ofilter)
-   have "f`(under r b) \<le> Field r'"
-   using t2 by (auto simp add: under_Field)
-   moreover
-   have "b \<in> under r b"
-   using t1 by(auto simp add: Refl Refl_under_in)
-   ultimately
-   have t4:  "f b \<in> Field r'" by auto
-   have "f`(under r b) = under r' (f b) \<and>
-         wo_rel.ofilter r' (f`(under r b)) \<and>
-         f b \<in> Field r'"
-   using t2 t3 t4 by auto
-  }
-  hence bFact:
-  "\<forall>b \<in> underS r a. f`(under r b) = under r' (f b) \<and>
-                       wo_rel.ofilter r' (f`(under r b)) \<and>
-                       f b \<in> Field r'" by blast
-  (*  *)
-  have subField: "f`(underS r a) \<le> Field r'"
-  using bFact by blast
-  (*  *)
-  have OF': "wo_rel.ofilter r' (f`(underS r a))"
-  proof-
-    have "f`(underS r a) = f`(\<Union>  b \<in> underS r a. under r b)"
-    using UN by auto
-    also have "\<dots> = (\<Union>  b \<in> underS r a. f`(under r b))" by blast
-    also have "\<dots> = (\<Union>  b \<in> underS r a. (under r' (f b)))"
-    using bFact by auto
-    finally
-    have "f`(underS r a) = (\<Union>  b \<in> underS r a. (under r' (f b)))" .
-    thus ?thesis
-    using Well' bFact
-          wo_rel.ofilter_UNION[of r' "underS r a" "\<lambda> b. under r' (f b)"] by fastforce
-  qed
-  (*  *)
-  have "f`(underS r a) \<union> AboveS r' (f`(underS r a)) = Field r'"
-  using Well' OF' by (auto simp add: wo_rel.ofilter_AboveS_Field)
-  hence NE: "AboveS r' (f`(underS r a)) \<noteq> {}"
-  using subField NOT by blast
-  (* Main proof *)
-  have INCL1: "f`(underS r a) \<le> underS r' (f a) "
-  proof(auto)
-    fix b assume *: "b \<in> underS r a"
-    have "f b \<noteq> f a \<and> (f b, f a) \<in> r'"
-    using subField Well' SUC NE *
-          wo_rel.suc_greater[of r' "f`(underS r a)" "f b"] by force
-    thus "f b \<in> underS r' (f a)"
-    unfolding underS_def by simp
-  qed
-  (*  *)
-  have INCL2: "underS r' (f a) \<le> f`(underS r a)"
-  proof
-    fix b' assume "b' \<in> underS r' (f a)"
-    hence "b' \<noteq> f a \<and> (b', f a) \<in> r'"
-    unfolding underS_def by simp
-    thus "b' \<in> f`(underS r a)"
-    using Well' SUC NE OF'
-          wo_rel.suc_ofilter_in[of r' "f ` underS r a" b'] by auto
-  qed
-  (*  *)
-  have INJ: "inj_on f (underS r a)"
-  proof-
-    have "\<forall>b \<in> underS r a. inj_on f (under r b)"
-    using IH by (auto simp add: bij_betw_def)
-    moreover
-    have "\<forall>b. wo_rel.ofilter r (under r b)"
-    using Well by (auto simp add: wo_rel.under_ofilter)
-    ultimately show  ?thesis
-    using WELL bFact UN
-          UNION_inj_on_ofilter[of r "underS r a" "\<lambda>b. under r b" f]
-    by auto
-  qed
-  (*  *)
-  have BIJ: "bij_betw f (underS r a) (underS r' (f a))"
-  unfolding bij_betw_def
-  using INJ INCL1 INCL2 by auto
-  (*  *)
-  have "f a \<in> Field r'"
-  using Well' subField NE SUC
-  by (auto simp add: wo_rel.suc_inField)
-  thus ?thesis
-  using WELL WELL' IN BIJ under_underS_bij_betw[of r r' a f] by auto
-qed
-
-
-lemma wellorders_totally_ordered_aux2:
-fixes r ::"'a rel"  and r'::"'a' rel" and
-      f :: "'a \<Rightarrow> 'a'" and g :: "'a \<Rightarrow> bool"  and a::'a
-assumes WELL: "Well_order r" and WELL': "Well_order r'" and
-MAIN1:
-  "\<And> a. (False \<notin> g`(underS r a) \<and> f`(underS r a) \<noteq> Field r'
-          \<longrightarrow> f a = wo_rel.suc r' (f`(underS r a)) \<and> g a = True)
-         \<and>
-         (\<not>(False \<notin> (g`(underS r a)) \<and> f`(underS r a) \<noteq> Field r')
-          \<longrightarrow> g a = False)" and
-MAIN2: "\<And> a. a \<in> Field r \<and> False \<notin> g`(under r a) \<longrightarrow>
-              bij_betw f (under r a) (under r' (f a))" and
-Case: "a \<in> Field r \<and> False \<in> g`(under r a)"
-shows "\<exists>f'. embed r' r f'"
-proof-
-  have Well: "wo_rel r" using WELL unfolding wo_rel_def .
-  hence Refl: "Refl r" using wo_rel.REFL[of r] by auto
-  have Trans: "trans r" using Well wo_rel.TRANS[of r] by auto
-  have Antisym: "antisym r" using Well wo_rel.ANTISYM[of r] by auto
-  have Well': "wo_rel r'" using WELL' unfolding wo_rel_def .
-  (*  *)
-  have 0: "under r a = underS r a \<union> {a}"
-  using Refl Case by(auto simp add: Refl_under_underS)
-  (*  *)
-  have 1: "g a = False"
-  proof-
-    {assume "g a \<noteq> False"
-     with 0 Case have "False \<in> g`(underS r a)" by blast
-     with MAIN1 have "g a = False" by blast}
-    thus ?thesis by blast
-  qed
-  let ?A = "{a \<in> Field r. g a = False}"
-  let ?a = "(wo_rel.minim r ?A)"
-  (*  *)
-  have 2: "?A \<noteq> {} \<and> ?A \<le> Field r" using Case 1 by blast
-  (*  *)
-  have 3: "False \<notin> g`(underS r ?a)"
-  proof
-    assume "False \<in> g`(underS r ?a)"
-    then obtain b where "b \<in> underS r ?a" and 31: "g b = False" by auto
-    hence 32: "(b,?a) \<in> r \<and> b \<noteq> ?a"
-    by (auto simp add: underS_def)
-    hence "b \<in> Field r" unfolding Field_def by auto
-    with 31 have "b \<in> ?A" by auto
-    hence "(?a,b) \<in> r" using wo_rel.minim_least 2 Well by fastforce
-    (* again: why worked without type annotations? *)
-    with 32 Antisym show False
-    by (auto simp add: antisym_def)
-  qed
-  have temp: "?a \<in> ?A"
-  using Well 2 wo_rel.minim_in[of r ?A] by auto
-  hence 4: "?a \<in> Field r" by auto
-  (*   *)
-  have 5: "g ?a = False" using temp by blast
-  (*  *)
-  have 6: "f`(underS r ?a) = Field r'"
-  using MAIN1[of ?a] 3 5 by blast
-  (*  *)
-  have 7: "\<forall>b \<in> underS r ?a. bij_betw f (under r b) (under r' (f b))"
-  proof
-    fix b assume as: "b \<in> underS r ?a"
-    moreover
-    have "wo_rel.ofilter r (underS r ?a)"
-    using Well by (auto simp add: wo_rel.underS_ofilter)
-    ultimately
-    have "False \<notin> g`(under r b)" using 3 Well by (subst (asm) wo_rel.ofilter_def) fast+
-    moreover have "b \<in> Field r"
-    unfolding Field_def using as by (auto simp add: underS_def)
-    ultimately
-    show "bij_betw f (under r b) (under r' (f b))"
-    using MAIN2 by auto
-  qed
-  (*  *)
-  have "embed r' r (inv_into (underS r ?a) f)"
-  using WELL WELL' 7 4 6 inv_into_underS_embed[of r ?a f r'] by auto
-  thus ?thesis
-  unfolding embed_def by blast
-qed
-
-
-theorem wellorders_totally_ordered:
-fixes r ::"'a rel"  and r'::"'a' rel"
-assumes WELL: "Well_order r" and WELL': "Well_order r'"
-shows "(\<exists>f. embed r r' f) \<or> (\<exists>f'. embed r' r f')"
-proof-
-  (* Preliminary facts *)
-  have Well: "wo_rel r" using WELL unfolding wo_rel_def .
-  hence Refl: "Refl r" using wo_rel.REFL[of r] by auto
-  have Trans: "trans r" using Well wo_rel.TRANS[of r] by auto
-  have Well': "wo_rel r'" using WELL' unfolding wo_rel_def .
-  (* Main proof *)
-  obtain H where H_def: "H =
-  (\<lambda>h a. if False \<notin> (snd o h)`(underS r a) \<and> (fst o h)`(underS r a) \<noteq> Field r'
-                then (wo_rel.suc r' ((fst o h)`(underS r a)), True)
-                else (undefined, False))" by blast
-  have Adm: "wo_rel.adm_wo r H"
-  using Well
-  proof(unfold wo_rel.adm_wo_def, clarify)
-    fix h1::"'a \<Rightarrow> 'a' * bool" and h2::"'a \<Rightarrow> 'a' * bool" and x
-    assume "\<forall>y\<in>underS r x. h1 y = h2 y"
-    hence "\<forall>y\<in>underS r x. (fst o h1) y = (fst o h2) y \<and>
-                          (snd o h1) y = (snd o h2) y" by auto
-    hence "(fst o h1)`(underS r x) = (fst o h2)`(underS r x) \<and>
-           (snd o h1)`(underS r x) = (snd o h2)`(underS r x)"
-      by (auto simp add: image_def)
-    thus "H h1 x = H h2 x" by (simp add: H_def del: not_False_in_image_Ball)
-  qed
-  (* More constant definitions:  *)
-  obtain h::"'a \<Rightarrow> 'a' * bool" and f::"'a \<Rightarrow> 'a'" and g::"'a \<Rightarrow> bool"
-  where h_def: "h = wo_rel.worec r H" and
-        f_def: "f = fst o h" and g_def: "g = snd o h" by blast
-  obtain test where test_def:
-  "test = (\<lambda> a. False \<notin> (g`(underS r a)) \<and> f`(underS r a) \<noteq> Field r')" by blast
-  (*  *)
-  have *: "\<And> a. h a  = H h a"
-  using Adm Well wo_rel.worec_fixpoint[of r H] by (simp add: h_def)
-  have Main1:
-  "\<And> a. (test a \<longrightarrow> f a = wo_rel.suc r' (f`(underS r a)) \<and> g a = True) \<and>
-         (\<not>(test a) \<longrightarrow> g a = False)"
-  proof-  (* How can I prove this withou fixing a? *)
-    fix a show "(test a \<longrightarrow> f a = wo_rel.suc r' (f`(underS r a)) \<and> g a = True) \<and>
-                (\<not>(test a) \<longrightarrow> g a = False)"
-    using *[of a] test_def f_def g_def H_def by auto
-  qed
-  (*  *)
-  let ?phi = "\<lambda> a. a \<in> Field r \<and> False \<notin> g`(under r a) \<longrightarrow>
-                   bij_betw f (under r a) (under r' (f a))"
-  have Main2: "\<And> a. ?phi a"
-  proof-
-    fix a show "?phi a"
-    proof(rule wo_rel.well_order_induct[of r ?phi],
-          simp only: Well, clarify)
-      fix a
-      assume IH: "\<forall>b. b \<noteq> a \<and> (b,a) \<in> r \<longrightarrow> ?phi b" and
-             *: "a \<in> Field r" and
-             **: "False \<notin> g`(under r a)"
-      have 1: "\<forall>b \<in> underS r a. bij_betw f (under r b) (under r' (f b))"
-      proof(clarify)
-        fix b assume ***: "b \<in> underS r a"
-        hence 0: "(b,a) \<in> r \<and> b \<noteq> a" unfolding underS_def by auto
-        moreover have "b \<in> Field r"
-        using *** underS_Field[of r a] by auto
-        moreover have "False \<notin> g`(under r b)"
-        using 0 ** Trans under_incr[of r b a] by auto
-        ultimately show "bij_betw f (under r b) (under r' (f b))"
-        using IH by auto
-      qed
-      (*  *)
-      have 21: "False \<notin> g`(underS r a)"
-      using ** underS_subset_under[of r a] by auto
-      have 22: "g`(under r a) \<le> {True}" using ** by auto
-      moreover have 23: "a \<in> under r a"
-      using Refl * by (auto simp add: Refl_under_in)
-      ultimately have 24: "g a = True" by blast
-      have 2: "f`(underS r a) \<noteq> Field r'"
-      proof
-        assume "f`(underS r a) = Field r'"
-        hence "g a = False" using Main1 test_def by blast
-        with 24 show False using ** by blast
-      qed
-      (*  *)
-      have 3: "f a = wo_rel.suc r' (f`(underS r a))"
-      using 21 2 Main1 test_def by blast
-      (*  *)
-      show "bij_betw f (under r a) (under r' (f a))"
-      using WELL  WELL' 1 2 3 *
-            wellorders_totally_ordered_aux[of r r' a f] by auto
-    qed
-  qed
-  (*  *)
-  let ?chi = "(\<lambda> a. a \<in> Field r \<and> False \<in> g`(under r a))"
-  show ?thesis
-  proof(cases "\<exists>a. ?chi a")
-    assume "\<not> (\<exists>a. ?chi a)"
-    hence "\<forall>a \<in> Field r.  bij_betw f (under r a) (under r' (f a))"
-    using Main2 by blast
-    thus ?thesis unfolding embed_def by blast
-  next
-    assume "\<exists>a. ?chi a"
-    then obtain a where "?chi a" by blast
-    hence "\<exists>f'. embed r' r f'"
-    using wellorders_totally_ordered_aux2[of r r' g f a]
-          WELL WELL' Main1 Main2 test_def by fast
-    thus ?thesis by blast
-  qed
-qed
-
-
-subsection {* Uniqueness of embeddings  *}
-
-
-text{* Here we show a fact complementary to the one from the previous subsection -- namely,
-that between any two well-orders there is {\em at most} one embedding, and is the one
-definable by the expected well-order recursive equation.  As a consequence, any two
-embeddings of opposite directions are mutually inverse. *}
-
-
-lemma embed_determined:
-assumes WELL: "Well_order r" and WELL': "Well_order r'" and
-        EMB: "embed r r' f" and IN: "a \<in> Field r"
-shows "f a = wo_rel.suc r' (f`(underS r a))"
-proof-
-  have "bij_betw f (underS r a) (underS r' (f a))"
-  using assms by (auto simp add: embed_underS)
-  hence "f`(underS r a) = underS r' (f a)"
-  by (auto simp add: bij_betw_def)
-  moreover
-  {have "f a \<in> Field r'" using IN
-   using EMB WELL embed_Field[of r r' f] by auto
-   hence "f a = wo_rel.suc r' (underS r' (f a))"
-   using WELL' by (auto simp add: wo_rel_def wo_rel.suc_underS)
-  }
-  ultimately show ?thesis by simp
-qed
-
-
-lemma embed_unique:
-assumes WELL: "Well_order r" and WELL': "Well_order r'" and
-        EMBf: "embed r r' f" and EMBg: "embed r r' g"
-shows "a \<in> Field r \<longrightarrow> f a = g a"
-proof(rule wo_rel.well_order_induct[of r], auto simp add: WELL wo_rel_def)
-  fix a
-  assume IH: "\<forall>b. b \<noteq> a \<and> (b,a): r \<longrightarrow> b \<in> Field r \<longrightarrow> f b = g b" and
-         *: "a \<in> Field r"
-  hence "\<forall>b \<in> underS r a. f b = g b"
-  unfolding underS_def by (auto simp add: Field_def)
-  hence "f`(underS r a) = g`(underS r a)" by force
-  thus "f a = g a"
-  using assms * embed_determined[of r r' f a] embed_determined[of r r' g a] by auto
-qed
-
-
-lemma embed_bothWays_inverse:
-assumes WELL: "Well_order r" and WELL': "Well_order r'" and
-        EMB: "embed r r' f" and EMB': "embed r' r f'"
-shows "(\<forall>a \<in> Field r. f'(f a) = a) \<and> (\<forall>a' \<in> Field r'. f(f' a') = a')"
-proof-
-  have "embed r r (f' o f)" using assms
-  by(auto simp add: comp_embed)
-  moreover have "embed r r id" using assms
-  by (auto simp add: id_embed)
-  ultimately have "\<forall>a \<in> Field r. f'(f a) = a"
-  using assms embed_unique[of r r "f' o f" id] id_def by auto
-  moreover
-  {have "embed r' r' (f o f')" using assms
-   by(auto simp add: comp_embed)
-   moreover have "embed r' r' id" using assms
-   by (auto simp add: id_embed)
-   ultimately have "\<forall>a' \<in> Field r'. f(f' a') = a'"
-   using assms embed_unique[of r' r' "f o f'" id] id_def by auto
-  }
-  ultimately show ?thesis by blast
-qed
-
-
-lemma embed_bothWays_bij_betw:
-assumes WELL: "Well_order r" and WELL': "Well_order r'" and
-        EMB: "embed r r' f" and EMB': "embed r' r g"
-shows "bij_betw f (Field r) (Field r')"
-proof-
-  let ?A = "Field r"  let ?A' = "Field r'"
-  have "embed r r (g o f) \<and> embed r' r' (f o g)"
-  using assms by (auto simp add: comp_embed)
-  hence 1: "(\<forall>a \<in> ?A. g(f a) = a) \<and> (\<forall>a' \<in> ?A'. f(g a') = a')"
-  using WELL id_embed[of r] embed_unique[of r r "g o f" id]
-        WELL' id_embed[of r'] embed_unique[of r' r' "f o g" id]
-        id_def by auto
-  have 2: "(\<forall>a \<in> ?A. f a \<in> ?A') \<and> (\<forall>a' \<in> ?A'. g a' \<in> ?A)"
-  using assms embed_Field[of r r' f] embed_Field[of r' r g] by blast
-  (*  *)
-  show ?thesis
-  proof(unfold bij_betw_def inj_on_def, auto simp add: 2)
-    fix a b assume *: "a \<in> ?A" "b \<in> ?A" and **: "f a = f b"
-    have "a = g(f a) \<and> b = g(f b)" using * 1 by auto
-    with ** show "a = b" by auto
-  next
-    fix a' assume *: "a' \<in> ?A'"
-    hence "g a' \<in> ?A \<and> f(g a') = a'" using 1 2 by auto
-    thus "a' \<in> f ` ?A" by force
-  qed
-qed
-
-
-lemma embed_bothWays_iso:
-assumes WELL: "Well_order r"  and WELL': "Well_order r'" and
-        EMB: "embed r r' f" and EMB': "embed r' r g"
-shows "iso r r' f"
-unfolding iso_def using assms by (auto simp add: embed_bothWays_bij_betw)
-
-
-subsection {* More properties of embeddings, strict embeddings and isomorphisms  *}
-
-
-lemma embed_bothWays_Field_bij_betw:
-assumes WELL: "Well_order r" and WELL': "Well_order r'" and
-        EMB: "embed r r' f" and EMB': "embed r' r f'"
-shows "bij_betw f (Field r) (Field r')"
-proof-
-  have "(\<forall>a \<in> Field r. f'(f a) = a) \<and> (\<forall>a' \<in> Field r'. f(f' a') = a')"
-  using assms by (auto simp add: embed_bothWays_inverse)
-  moreover
-  have "f`(Field r) \<le> Field r' \<and> f' ` (Field r') \<le> Field r"
-  using assms by (auto simp add: embed_Field)
-  ultimately
-  show ?thesis using bij_betw_byWitness[of "Field r" f' f "Field r'"] by auto
-qed
-
-
-lemma embedS_comp_embed:
-assumes WELL: "Well_order r" and WELL': "Well_order r'" and WELL'': "Well_order r''"
-        and  EMB: "embedS r r' f" and EMB': "embed r' r'' f'"
-shows "embedS r r'' (f' o f)"
-proof-
-  let ?g = "(f' o f)"  let ?h = "inv_into (Field r) ?g"
-  have 1: "embed r r' f \<and> \<not> (bij_betw f (Field r) (Field r'))"
-  using EMB by (auto simp add: embedS_def)
-  hence 2: "embed r r'' ?g"
-  using WELL EMB' comp_embed[of r r' f r'' f'] by auto
-  moreover
-  {assume "bij_betw ?g (Field r) (Field r'')"
-   hence "embed r'' r ?h" using 2 WELL
-   by (auto simp add: inv_into_Field_embed_bij_betw)
-   hence "embed r' r (?h o f')" using WELL' EMB'
-   by (auto simp add: comp_embed)
-   hence "bij_betw f (Field r) (Field r')" using WELL WELL' 1
-   by (auto simp add: embed_bothWays_Field_bij_betw)
-   with 1 have False by blast
-  }
-  ultimately show ?thesis unfolding embedS_def by auto
-qed
-
-
-lemma embed_comp_embedS:
-assumes WELL: "Well_order r" and WELL': "Well_order r'" and WELL'': "Well_order r''"
-        and  EMB: "embed r r' f" and EMB': "embedS r' r'' f'"
-shows "embedS r r'' (f' o f)"
-proof-
-  let ?g = "(f' o f)"  let ?h = "inv_into (Field r) ?g"
-  have 1: "embed r' r'' f' \<and> \<not> (bij_betw f' (Field r') (Field r''))"
-  using EMB' by (auto simp add: embedS_def)
-  hence 2: "embed r r'' ?g"
-  using WELL EMB comp_embed[of r r' f r'' f'] by auto
-  moreover
-  {assume "bij_betw ?g (Field r) (Field r'')"
-   hence "embed r'' r ?h" using 2 WELL
-   by (auto simp add: inv_into_Field_embed_bij_betw)
-   hence "embed r'' r' (f o ?h)" using WELL'' EMB
-   by (auto simp add: comp_embed)
-   hence "bij_betw f' (Field r') (Field r'')" using WELL' WELL'' 1
-   by (auto simp add: embed_bothWays_Field_bij_betw)
-   with 1 have False by blast
-  }
-  ultimately show ?thesis unfolding embedS_def by auto
-qed
-
-
-lemma embed_comp_iso:
-assumes WELL: "Well_order r" and WELL': "Well_order r'" and WELL'': "Well_order r''"
-        and  EMB: "embed r r' f" and EMB': "iso r' r'' f'"
-shows "embed r r'' (f' o f)"
-using assms unfolding iso_def
-by (auto simp add: comp_embed)
-
-
-lemma iso_comp_embed:
-assumes WELL: "Well_order r" and WELL': "Well_order r'" and WELL'': "Well_order r''"
-        and  EMB: "iso r r' f" and EMB': "embed r' r'' f'"
-shows "embed r r'' (f' o f)"
-using assms unfolding iso_def
-by (auto simp add: comp_embed)
-
-
-lemma embedS_comp_iso:
-assumes WELL: "Well_order r" and WELL': "Well_order r'" and WELL'': "Well_order r''"
-        and  EMB: "embedS r r' f" and EMB': "iso r' r'' f'"
-shows "embedS r r'' (f' o f)"
-using assms unfolding iso_def
-by (auto simp add: embedS_comp_embed)
-
-
-lemma iso_comp_embedS:
-assumes WELL: "Well_order r" and WELL': "Well_order r'" and WELL'': "Well_order r''"
-        and  EMB: "iso r r' f" and EMB': "embedS r' r'' f'"
-shows "embedS r r'' (f' o f)"
-using assms unfolding iso_def  using embed_comp_embedS
-by (auto simp add: embed_comp_embedS)
-
-
-lemma embedS_Field:
-assumes WELL: "Well_order r" and EMB: "embedS r r' f"
-shows "f ` (Field r) < Field r'"
-proof-
-  have "f`(Field r) \<le> Field r'" using assms
-  by (auto simp add: embed_Field embedS_def)
-  moreover
-  {have "inj_on f (Field r)" using assms
-   by (auto simp add: embedS_def embed_inj_on)
-   hence "f`(Field r) \<noteq> Field r'" using EMB
-   by (auto simp add: embedS_def bij_betw_def)
-  }
-  ultimately show ?thesis by blast
-qed
-
-
-lemma embedS_iff:
-assumes WELL: "Well_order r" and ISO: "embed r r' f"
-shows "embedS r r' f = (f ` (Field r) < Field r')"
-proof
-  assume "embedS r r' f"
-  thus "f ` Field r \<subset> Field r'"
-  using WELL by (auto simp add: embedS_Field)
-next
-  assume "f ` Field r \<subset> Field r'"
-  hence "\<not> bij_betw f (Field r) (Field r')"
-  unfolding bij_betw_def by blast
-  thus "embedS r r' f" unfolding embedS_def
-  using ISO by auto
-qed
-
-
-lemma iso_Field:
-"iso r r' f \<Longrightarrow> f ` (Field r) = Field r'"
-using assms by (auto simp add: iso_def bij_betw_def)
-
-
-lemma iso_iff:
-assumes "Well_order r"
-shows "iso r r' f = (embed r r' f \<and> f ` (Field r) = Field r')"
-proof
-  assume "iso r r' f"
-  thus "embed r r' f \<and> f ` (Field r) = Field r'"
-  by (auto simp add: iso_Field iso_def)
-next
-  assume *: "embed r r' f \<and> f ` Field r = Field r'"
-  hence "inj_on f (Field r)" using assms by (auto simp add: embed_inj_on)
-  with * have "bij_betw f (Field r) (Field r')"
-  unfolding bij_betw_def by simp
-  with * show "iso r r' f" unfolding iso_def by auto
-qed
-
-
-lemma iso_iff2:
-assumes "Well_order r"
-shows "iso r r' f = (bij_betw f (Field r) (Field r') \<and>
-                     (\<forall>a \<in> Field r. \<forall>b \<in> Field r.
-                         (((a,b) \<in> r) = ((f a, f b) \<in> r'))))"
-using assms
-proof(auto simp add: iso_def)
-  fix a b
-  assume "embed r r' f"
-  hence "compat r r' f" using embed_compat[of r] by auto
-  moreover assume "(a,b) \<in> r"
-  ultimately show "(f a, f b) \<in> r'" using compat_def[of r] by auto
-next
-  let ?f' = "inv_into (Field r) f"
-  assume "embed r r' f" and 1: "bij_betw f (Field r) (Field r')"
-  hence "embed r' r ?f'" using assms
-  by (auto simp add: inv_into_Field_embed_bij_betw)
-  hence 2: "compat r' r ?f'" using embed_compat[of r'] by auto
-  fix a b assume *: "a \<in> Field r" "b \<in> Field r" and **: "(f a,f b) \<in> r'"
-  hence "?f'(f a) = a \<and> ?f'(f b) = b" using 1
-  by (auto simp add: bij_betw_inv_into_left)
-  thus "(a,b) \<in> r" using ** 2 compat_def[of r' r ?f'] by fastforce
-next
-  assume *: "bij_betw f (Field r) (Field r')" and
-         **: "\<forall>a\<in>Field r. \<forall>b\<in>Field r. ((a, b) \<in> r) = ((f a, f b) \<in> r')"
-  have 1: "\<And> a. under r a \<le> Field r \<and> under r' (f a) \<le> Field r'"
-  by (auto simp add: under_Field)
-  have 2: "inj_on f (Field r)" using * by (auto simp add: bij_betw_def)
-  {fix a assume ***: "a \<in> Field r"
-   have "bij_betw f (under r a) (under r' (f a))"
-   proof(unfold bij_betw_def, auto)
-     show "inj_on f (under r a)"
-     using 1 2 by (metis subset_inj_on)
-   next
-     fix b assume "b \<in> under r a"
-     hence "a \<in> Field r \<and> b \<in> Field r \<and> (b,a) \<in> r"
-     unfolding under_def by (auto simp add: Field_def Range_def Domain_def)
-     with 1 ** show "f b \<in> under r' (f a)"
-     unfolding under_def by auto
-   next
-     fix b' assume "b' \<in> under r' (f a)"
-     hence 3: "(b',f a) \<in> r'" unfolding under_def by simp
-     hence "b' \<in> Field r'" unfolding Field_def by auto
-     with * obtain b where "b \<in> Field r \<and> f b = b'"
-     unfolding bij_betw_def by force
-     with 3 ** ***
-     show "b' \<in> f ` (under r a)" unfolding under_def by blast
-   qed
-  }
-  thus "embed r r' f" unfolding embed_def using * by auto
-qed
-
-
-lemma iso_iff3:
-assumes WELL: "Well_order r" and WELL': "Well_order r'"
-shows "iso r r' f = (bij_betw f (Field r) (Field r') \<and> compat r r' f)"
-proof
-  assume "iso r r' f"
-  thus "bij_betw f (Field r) (Field r') \<and> compat r r' f"
-  unfolding compat_def using WELL by (auto simp add: iso_iff2 Field_def)
-next
-  have Well: "wo_rel r \<and> wo_rel r'" using WELL WELL'
-  by (auto simp add: wo_rel_def)
-  assume *: "bij_betw f (Field r) (Field r') \<and> compat r r' f"
-  thus "iso r r' f"
-  unfolding "compat_def" using assms
-  proof(auto simp add: iso_iff2)
-    fix a b assume **: "a \<in> Field r" "b \<in> Field r" and
-                  ***: "(f a, f b) \<in> r'"
-    {assume "(b,a) \<in> r \<or> b = a"
-     hence "(b,a): r"using Well ** wo_rel.REFL[of r] refl_on_def[of _ r] by blast
-     hence "(f b, f a) \<in> r'" using * unfolding compat_def by auto
-     hence "f a = f b"
-     using Well *** wo_rel.ANTISYM[of r'] antisym_def[of r'] by blast
-     hence "a = b" using * ** unfolding bij_betw_def inj_on_def by auto
-     hence "(a,b) \<in> r" using Well ** wo_rel.REFL[of r] refl_on_def[of _ r] by blast
-    }
-    thus "(a,b) \<in> r"
-    using Well ** wo_rel.TOTAL[of r] total_on_def[of _ r] by blast
-  qed
-qed
-
-
-
-end
--- a/src/HOL/Cardinals/Wellorder_Relation_FP.thy	Mon Jan 20 16:14:19 2014 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,642 +0,0 @@
-(*  Title:      HOL/Cardinals/Wellorder_Relation_FP.thy
-    Author:     Andrei Popescu, TU Muenchen
-    Copyright   2012
-
-Well-order relations (FP).
-*)
-
-header {* Well-Order Relations (FP) *}
-
-theory Wellorder_Relation_FP
-imports Order_Relation
-begin
-
-
-text{* In this section, we develop basic concepts and results pertaining
-to well-order relations.  Note that we consider well-order relations
-as {\em non-strict relations},
-i.e., as containing the diagonals of their fields. *}
-
-
-locale wo_rel =
-  fixes r :: "'a rel"
-  assumes WELL: "Well_order r"
-begin
-
-text{* The following context encompasses all this section. In other words,
-for the whole section, we consider a fixed well-order relation @{term "r"}. *}
-
-(* context wo_rel  *)
-
-abbreviation under where "under \<equiv> Order_Relation.under r"
-abbreviation underS where "underS \<equiv> Order_Relation.underS r"
-abbreviation Under where "Under \<equiv> Order_Relation.Under r"
-abbreviation UnderS where "UnderS \<equiv> Order_Relation.UnderS r"
-abbreviation above where "above \<equiv> Order_Relation.above r"
-abbreviation aboveS where "aboveS \<equiv> Order_Relation.aboveS r"
-abbreviation Above where "Above \<equiv> Order_Relation.Above r"
-abbreviation AboveS where "AboveS \<equiv> Order_Relation.AboveS r"
-
-
-subsection {* Auxiliaries *}
-
-
-lemma REFL: "Refl r"
-using WELL order_on_defs[of _ r] by auto
-
-
-lemma TRANS: "trans r"
-using WELL order_on_defs[of _ r] by auto
-
-
-lemma ANTISYM: "antisym r"
-using WELL order_on_defs[of _ r] by auto
-
-
-lemma TOTAL: "Total r"
-using WELL order_on_defs[of _ r] by auto
-
-
-lemma TOTALS: "\<forall>a \<in> Field r. \<forall>b \<in> Field r. (a,b) \<in> r \<or> (b,a) \<in> r"
-using REFL TOTAL refl_on_def[of _ r] total_on_def[of _ r] by force
-
-
-lemma LIN: "Linear_order r"
-using WELL well_order_on_def[of _ r] by auto
-
-
-lemma WF: "wf (r - Id)"
-using WELL well_order_on_def[of _ r] by auto
-
-
-lemma cases_Total:
-"\<And> phi a b. \<lbrakk>{a,b} <= Field r; ((a,b) \<in> r \<Longrightarrow> phi a b); ((b,a) \<in> r \<Longrightarrow> phi a b)\<rbrakk>
-             \<Longrightarrow> phi a b"
-using TOTALS by auto
-
-
-lemma cases_Total3:
-"\<And> phi a b. \<lbrakk>{a,b} \<le> Field r; ((a,b) \<in> r - Id \<or> (b,a) \<in> r - Id \<Longrightarrow> phi a b);
-              (a = b \<Longrightarrow> phi a b)\<rbrakk>  \<Longrightarrow> phi a b"
-using TOTALS by auto
-
-
-subsection {* Well-founded induction and recursion adapted to non-strict well-order relations  *}
-
-
-text{* Here we provide induction and recursion principles specific to {\em non-strict}
-well-order relations.
-Although minor variations of those for well-founded relations, they will be useful
-for doing away with the tediousness of
-having to take out the diagonal each time in order to switch to a well-founded relation. *}
-
-
-lemma well_order_induct:
-assumes IND: "\<And>x. \<forall>y. y \<noteq> x \<and> (y, x) \<in> r \<longrightarrow> P y \<Longrightarrow> P x"
-shows "P a"
-proof-
-  have "\<And>x. \<forall>y. (y, x) \<in> r - Id \<longrightarrow> P y \<Longrightarrow> P x"
-  using IND by blast
-  thus "P a" using WF wf_induct[of "r - Id" P a] by blast
-qed
-
-
-definition
-worec :: "(('a \<Rightarrow> 'b) \<Rightarrow> 'a \<Rightarrow> 'b) \<Rightarrow> 'a \<Rightarrow> 'b"
-where
-"worec F \<equiv> wfrec (r - Id) F"
-
-
-definition
-adm_wo :: "(('a \<Rightarrow> 'b) \<Rightarrow> 'a \<Rightarrow> 'b) \<Rightarrow> bool"
-where
-"adm_wo H \<equiv> \<forall>f g x. (\<forall>y \<in> underS x. f y = g y) \<longrightarrow> H f x = H g x"
-
-
-lemma worec_fixpoint:
-assumes ADM: "adm_wo H"
-shows "worec H = H (worec H)"
-proof-
-  let ?rS = "r - Id"
-  have "adm_wf (r - Id) H"
-  unfolding adm_wf_def
-  using ADM adm_wo_def[of H] underS_def[of r] by auto
-  hence "wfrec ?rS H = H (wfrec ?rS H)"
-  using WF wfrec_fixpoint[of ?rS H] by simp
-  thus ?thesis unfolding worec_def .
-qed
-
-
-subsection {* The notions of maximum, minimum, supremum, successor and order filter  *}
-
-
-text{*
-We define the successor {\em of a set}, and not of an element (the latter is of course
-a particular case).  Also, we define the maximum {\em of two elements}, @{text "max2"},
-and the minimum {\em of a set}, @{text "minim"} -- we chose these variants since we
-consider them the most useful for well-orders.  The minimum is defined in terms of the
-auxiliary relational operator @{text "isMinim"}.  Then, supremum and successor are
-defined in terms of minimum as expected.
-The minimum is only meaningful for non-empty sets, and the successor is only
-meaningful for sets for which strict upper bounds exist.
-Order filters for well-orders are also known as ``initial segments". *}
-
-
-definition max2 :: "'a \<Rightarrow> 'a \<Rightarrow> 'a"
-where "max2 a b \<equiv> if (a,b) \<in> r then b else a"
-
-
-definition isMinim :: "'a set \<Rightarrow> 'a \<Rightarrow> bool"
-where "isMinim A b \<equiv> b \<in> A \<and> (\<forall>a \<in> A. (b,a) \<in> r)"
-
-definition minim :: "'a set \<Rightarrow> 'a"
-where "minim A \<equiv> THE b. isMinim A b"
-
-
-definition supr :: "'a set \<Rightarrow> 'a"
-where "supr A \<equiv> minim (Above A)"
-
-definition suc :: "'a set \<Rightarrow> 'a"
-where "suc A \<equiv> minim (AboveS A)"
-
-definition ofilter :: "'a set \<Rightarrow> bool"
-where
-"ofilter A \<equiv> (A \<le> Field r) \<and> (\<forall>a \<in> A. under a \<le> A)"
-
-
-subsubsection {* Properties of max2 *}
-
-
-lemma max2_greater_among:
-assumes "a \<in> Field r" and "b \<in> Field r"
-shows "(a, max2 a b) \<in> r \<and> (b, max2 a b) \<in> r \<and> max2 a b \<in> {a,b}"
-proof-
-  {assume "(a,b) \<in> r"
-   hence ?thesis using max2_def assms REFL refl_on_def
-   by (auto simp add: refl_on_def)
-  }
-  moreover
-  {assume "a = b"
-   hence "(a,b) \<in> r" using REFL  assms
-   by (auto simp add: refl_on_def)
-  }
-  moreover
-  {assume *: "a \<noteq> b \<and> (b,a) \<in> r"
-   hence "(a,b) \<notin> r" using ANTISYM
-   by (auto simp add: antisym_def)
-   hence ?thesis using * max2_def assms REFL refl_on_def
-   by (auto simp add: refl_on_def)
-  }
-  ultimately show ?thesis using assms TOTAL
-  total_on_def[of "Field r" r] by blast
-qed
-
-
-lemma max2_greater:
-assumes "a \<in> Field r" and "b \<in> Field r"
-shows "(a, max2 a b) \<in> r \<and> (b, max2 a b) \<in> r"
-using assms by (auto simp add: max2_greater_among)
-
-
-lemma max2_among:
-assumes "a \<in> Field r" and "b \<in> Field r"
-shows "max2 a b \<in> {a, b}"
-using assms max2_greater_among[of a b] by simp
-
-
-lemma max2_equals1:
-assumes "a \<in> Field r" and "b \<in> Field r"
-shows "(max2 a b = a) = ((b,a) \<in> r)"
-using assms ANTISYM unfolding antisym_def using TOTALS
-by(auto simp add: max2_def max2_among)
-
-
-lemma max2_equals2:
-assumes "a \<in> Field r" and "b \<in> Field r"
-shows "(max2 a b = b) = ((a,b) \<in> r)"
-using assms ANTISYM unfolding antisym_def using TOTALS
-unfolding max2_def by auto
-
-
-subsubsection {* Existence and uniqueness for isMinim and well-definedness of minim *}
-
-
-lemma isMinim_unique:
-assumes MINIM: "isMinim B a" and MINIM': "isMinim B a'"
-shows "a = a'"
-proof-
-  {have "a \<in> B"
-   using MINIM isMinim_def by simp
-   hence "(a',a) \<in> r"
-   using MINIM' isMinim_def by simp
-  }
-  moreover
-  {have "a' \<in> B"
-   using MINIM' isMinim_def by simp
-   hence "(a,a') \<in> r"
-   using MINIM isMinim_def by simp
-  }
-  ultimately
-  show ?thesis using ANTISYM antisym_def[of r] by blast
-qed
-
-
-lemma Well_order_isMinim_exists:
-assumes SUB: "B \<le> Field r" and NE: "B \<noteq> {}"
-shows "\<exists>b. isMinim B b"
-proof-
-  from spec[OF WF[unfolded wf_eq_minimal[of "r - Id"]], of B] NE obtain b where
-  *: "b \<in> B \<and> (\<forall>b'. b' \<noteq> b \<and> (b',b) \<in> r \<longrightarrow> b' \<notin> B)" by auto
-  show ?thesis
-  proof(simp add: isMinim_def, rule exI[of _ b], auto)
-    show "b \<in> B" using * by simp
-  next
-    fix b' assume As: "b' \<in> B"
-    hence **: "b \<in> Field r \<and> b' \<in> Field r" using As SUB * by auto
-    (*  *)
-    from As  * have "b' = b \<or> (b',b) \<notin> r" by auto
-    moreover
-    {assume "b' = b"
-     hence "(b,b') \<in> r"
-     using ** REFL by (auto simp add: refl_on_def)
-    }
-    moreover
-    {assume "b' \<noteq> b \<and> (b',b) \<notin> r"
-     hence "(b,b') \<in> r"
-     using ** TOTAL by (auto simp add: total_on_def)
-    }
-    ultimately show "(b,b') \<in> r" by blast
-  qed
-qed
-
-
-lemma minim_isMinim:
-assumes SUB: "B \<le> Field r" and NE: "B \<noteq> {}"
-shows "isMinim B (minim B)"
-proof-
-  let ?phi = "(\<lambda> b. isMinim B b)"
-  from assms Well_order_isMinim_exists
-  obtain b where *: "?phi b" by blast
-  moreover
-  have "\<And> b'. ?phi b' \<Longrightarrow> b' = b"
-  using isMinim_unique * by auto
-  ultimately show ?thesis
-  unfolding minim_def using theI[of ?phi b] by blast
-qed
-
-
-subsubsection{* Properties of minim *}
-
-
-lemma minim_in:
-assumes "B \<le> Field r" and "B \<noteq> {}"
-shows "minim B \<in> B"
-proof-
-  from minim_isMinim[of B] assms
-  have "isMinim B (minim B)" by simp
-  thus ?thesis by (simp add: isMinim_def)
-qed
-
-
-lemma minim_inField:
-assumes "B \<le> Field r" and "B \<noteq> {}"
-shows "minim B \<in> Field r"
-proof-
-  have "minim B \<in> B" using assms by (simp add: minim_in)
-  thus ?thesis using assms by blast
-qed
-
-
-lemma minim_least:
-assumes  SUB: "B \<le> Field r" and IN: "b \<in> B"
-shows "(minim B, b) \<in> r"
-proof-
-  from minim_isMinim[of B] assms
-  have "isMinim B (minim B)" by auto
-  thus ?thesis by (auto simp add: isMinim_def IN)
-qed
-
-
-lemma equals_minim:
-assumes SUB: "B \<le> Field r" and IN: "a \<in> B" and
-        LEAST: "\<And> b. b \<in> B \<Longrightarrow> (a,b) \<in> r"
-shows "a = minim B"
-proof-
-  from minim_isMinim[of B] assms
-  have "isMinim B (minim B)" by auto
-  moreover have "isMinim B a" using IN LEAST isMinim_def by auto
-  ultimately show ?thesis
-  using isMinim_unique by auto
-qed
-
-
-subsubsection{* Properties of successor *}
-
-
-lemma suc_AboveS:
-assumes SUB: "B \<le> Field r" and ABOVES: "AboveS B \<noteq> {}"
-shows "suc B \<in> AboveS B"
-proof(unfold suc_def)
-  have "AboveS B \<le> Field r"
-  using AboveS_Field[of r] by auto
-  thus "minim (AboveS B) \<in> AboveS B"
-  using assms by (simp add: minim_in)
-qed
-
-
-lemma suc_greater:
-assumes SUB: "B \<le> Field r" and ABOVES: "AboveS B \<noteq> {}" and
-        IN: "b \<in> B"
-shows "suc B \<noteq> b \<and> (b,suc B) \<in> r"
-proof-
-  from assms suc_AboveS
-  have "suc B \<in> AboveS B" by simp
-  with IN AboveS_def[of r] show ?thesis by simp
-qed
-
-
-lemma suc_least_AboveS:
-assumes ABOVES: "a \<in> AboveS B"
-shows "(suc B,a) \<in> r"
-proof(unfold suc_def)
-  have "AboveS B \<le> Field r"
-  using AboveS_Field[of r] by auto
-  thus "(minim (AboveS B),a) \<in> r"
-  using assms minim_least by simp
-qed
-
-
-lemma suc_inField:
-assumes "B \<le> Field r" and "AboveS B \<noteq> {}"
-shows "suc B \<in> Field r"
-proof-
-  have "suc B \<in> AboveS B" using suc_AboveS assms by simp
-  thus ?thesis
-  using assms AboveS_Field[of r] by auto
-qed
-
-
-lemma equals_suc_AboveS:
-assumes SUB: "B \<le> Field r" and ABV: "a \<in> AboveS B" and
-        MINIM: "\<And> a'. a' \<in> AboveS B \<Longrightarrow> (a,a') \<in> r"
-shows "a = suc B"
-proof(unfold suc_def)
-  have "AboveS B \<le> Field r"
-  using AboveS_Field[of r B] by auto
-  thus "a = minim (AboveS B)"
-  using assms equals_minim
-  by simp
-qed
-
-
-lemma suc_underS:
-assumes IN: "a \<in> Field r"
-shows "a = suc (underS a)"
-proof-
-  have "underS a \<le> Field r"
-  using underS_Field[of r] by auto
-  moreover
-  have "a \<in> AboveS (underS a)"
-  using in_AboveS_underS IN by fast
-  moreover
-  have "\<forall>a' \<in> AboveS (underS a). (a,a') \<in> r"
-  proof(clarify)
-    fix a'
-    assume *: "a' \<in> AboveS (underS a)"
-    hence **: "a' \<in> Field r"
-    using AboveS_Field by fast
-    {assume "(a,a') \<notin> r"
-     hence "a' = a \<or> (a',a) \<in> r"
-     using TOTAL IN ** by (auto simp add: total_on_def)
-     moreover
-     {assume "a' = a"
-      hence "(a,a') \<in> r"
-      using REFL IN ** by (auto simp add: refl_on_def)
-     }
-     moreover
-     {assume "a' \<noteq> a \<and> (a',a) \<in> r"
-      hence "a' \<in> underS a"
-      unfolding underS_def by simp
-      hence "a' \<notin> AboveS (underS a)"
-      using AboveS_disjoint by fast
-      with * have False by simp
-     }
-     ultimately have "(a,a') \<in> r" by blast
-    }
-    thus  "(a, a') \<in> r" by blast
-  qed
-  ultimately show ?thesis
-  using equals_suc_AboveS by auto
-qed
-
-
-subsubsection {* Properties of order filters *}
-
-
-lemma under_ofilter:
-"ofilter (under a)"
-proof(unfold ofilter_def under_def, auto simp add: Field_def)
-  fix aa x
-  assume "(aa,a) \<in> r" "(x,aa) \<in> r"
-  thus "(x,a) \<in> r"
-  using TRANS trans_def[of r] by blast
-qed
-
-
-lemma underS_ofilter:
-"ofilter (underS a)"
-proof(unfold ofilter_def underS_def under_def, auto simp add: Field_def)
-  fix aa assume "(a, aa) \<in> r" "(aa, a) \<in> r" and DIFF: "aa \<noteq> a"
-  thus False
-  using ANTISYM antisym_def[of r] by blast
-next
-  fix aa x
-  assume "(aa,a) \<in> r" "aa \<noteq> a" "(x,aa) \<in> r"
-  thus "(x,a) \<in> r"
-  using TRANS trans_def[of r] by blast
-qed
-
-
-lemma Field_ofilter:
-"ofilter (Field r)"
-by(unfold ofilter_def under_def, auto simp add: Field_def)
-
-
-lemma ofilter_underS_Field:
-"ofilter A = ((\<exists>a \<in> Field r. A = underS a) \<or> (A = Field r))"
-proof
-  assume "(\<exists>a\<in>Field r. A = underS a) \<or> A = Field r"
-  thus "ofilter A"
-  by (auto simp: underS_ofilter Field_ofilter)
-next
-  assume *: "ofilter A"
-  let ?One = "(\<exists>a\<in>Field r. A = underS a)"
-  let ?Two = "(A = Field r)"
-  show "?One \<or> ?Two"
-  proof(cases ?Two, simp)
-    let ?B = "(Field r) - A"
-    let ?a = "minim ?B"
-    assume "A \<noteq> Field r"
-    moreover have "A \<le> Field r" using * ofilter_def by simp
-    ultimately have 1: "?B \<noteq> {}" by blast
-    hence 2: "?a \<in> Field r" using minim_inField[of ?B] by blast
-    have 3: "?a \<in> ?B" using minim_in[of ?B] 1 by blast
-    hence 4: "?a \<notin> A" by blast
-    have 5: "A \<le> Field r" using * ofilter_def[of A] by auto
-    (*  *)
-    moreover
-    have "A = underS ?a"
-    proof
-      show "A \<le> underS ?a"
-      proof(unfold underS_def, auto simp add: 4)
-        fix x assume **: "x \<in> A"
-        hence 11: "x \<in> Field r" using 5 by auto
-        have 12: "x \<noteq> ?a" using 4 ** by auto
-        have 13: "under x \<le> A" using * ofilter_def ** by auto
-        {assume "(x,?a) \<notin> r"
-         hence "(?a,x) \<in> r"
-         using TOTAL total_on_def[of "Field r" r]
-               2 4 11 12 by auto
-         hence "?a \<in> under x" using under_def[of r] by auto
-         hence "?a \<in> A" using ** 13 by blast
-         with 4 have False by simp
-        }
-        thus "(x,?a) \<in> r" by blast
-      qed
-    next
-      show "underS ?a \<le> A"
-      proof(unfold underS_def, auto)
-        fix x
-        assume **: "x \<noteq> ?a" and ***: "(x,?a) \<in> r"
-        hence 11: "x \<in> Field r" using Field_def by fastforce
-         {assume "x \<notin> A"
-          hence "x \<in> ?B" using 11 by auto
-          hence "(?a,x) \<in> r" using 3 minim_least[of ?B x] by blast
-          hence False
-          using ANTISYM antisym_def[of r] ** *** by auto
-         }
-        thus "x \<in> A" by blast
-      qed
-    qed
-    ultimately have ?One using 2 by blast
-    thus ?thesis by simp
-  qed
-qed
-
-
-lemma ofilter_UNION:
-"(\<And> i. i \<in> I \<Longrightarrow> ofilter(A i)) \<Longrightarrow> ofilter (\<Union> i \<in> I. A i)"
-unfolding ofilter_def by blast
-
-
-lemma ofilter_under_UNION:
-assumes "ofilter A"
-shows "A = (\<Union> a \<in> A. under a)"
-proof
-  have "\<forall>a \<in> A. under a \<le> A"
-  using assms ofilter_def by auto
-  thus "(\<Union> a \<in> A. under a) \<le> A" by blast
-next
-  have "\<forall>a \<in> A. a \<in> under a"
-  using REFL Refl_under_in[of r] assms ofilter_def[of A] by blast
-  thus "A \<le> (\<Union> a \<in> A. under a)" by blast
-qed
-
-
-subsubsection{* Other properties *}
-
-
-lemma ofilter_linord:
-assumes OF1: "ofilter A" and OF2: "ofilter B"
-shows "A \<le> B \<or> B \<le> A"
-proof(cases "A = Field r")
-  assume Case1: "A = Field r"
-  hence "B \<le> A" using OF2 ofilter_def by auto
-  thus ?thesis by simp
-next
-  assume Case2: "A \<noteq> Field r"
-  with ofilter_underS_Field OF1 obtain a where
-  1: "a \<in> Field r \<and> A = underS a" by auto
-  show ?thesis
-  proof(cases "B = Field r")
-    assume Case21: "B = Field r"
-    hence "A \<le> B" using OF1 ofilter_def by auto
-    thus ?thesis by simp
-  next
-    assume Case22: "B \<noteq> Field r"
-    with ofilter_underS_Field OF2 obtain b where
-    2: "b \<in> Field r \<and> B = underS b" by auto
-    have "a = b \<or> (a,b) \<in> r \<or> (b,a) \<in> r"
-    using 1 2 TOTAL total_on_def[of _ r] by auto
-    moreover
-    {assume "a = b" with 1 2 have ?thesis by auto
-    }
-    moreover
-    {assume "(a,b) \<in> r"
-     with underS_incr[of r] TRANS ANTISYM 1 2
-     have "A \<le> B" by auto
-     hence ?thesis by auto
-    }
-    moreover
-     {assume "(b,a) \<in> r"
-     with underS_incr[of r] TRANS ANTISYM 1 2
-     have "B \<le> A" by auto
-     hence ?thesis by auto
-    }
-    ultimately show ?thesis by blast
-  qed
-qed
-
-
-lemma ofilter_AboveS_Field:
-assumes "ofilter A"
-shows "A \<union> (AboveS A) = Field r"
-proof
-  show "A \<union> (AboveS A) \<le> Field r"
-  using assms ofilter_def AboveS_Field[of r] by auto
-next
-  {fix x assume *: "x \<in> Field r" and **: "x \<notin> A"
-   {fix y assume ***: "y \<in> A"
-    with ** have 1: "y \<noteq> x" by auto
-    {assume "(y,x) \<notin> r"
-     moreover
-     have "y \<in> Field r" using assms ofilter_def *** by auto
-     ultimately have "(x,y) \<in> r"
-     using 1 * TOTAL total_on_def[of _ r] by auto
-     with *** assms ofilter_def under_def[of r] have "x \<in> A" by auto
-     with ** have False by contradiction
-    }
-    hence "(y,x) \<in> r" by blast
-    with 1 have "y \<noteq> x \<and> (y,x) \<in> r" by auto
-   }
-   with * have "x \<in> AboveS A" unfolding AboveS_def by auto
-  }
-  thus "Field r \<le> A \<union> (AboveS A)" by blast
-qed
-
-
-lemma suc_ofilter_in:
-assumes OF: "ofilter A" and ABOVE_NE: "AboveS A \<noteq> {}" and
-        REL: "(b,suc A) \<in> r" and DIFF: "b \<noteq> suc A"
-shows "b \<in> A"
-proof-
-  have *: "suc A \<in> Field r \<and> b \<in> Field r"
-  using WELL REL well_order_on_domain[of "Field r"] by auto
-  {assume **: "b \<notin> A"
-   hence "b \<in> AboveS A"
-   using OF * ofilter_AboveS_Field by auto
-   hence "(suc A, b) \<in> r"
-   using suc_least_AboveS by auto
-   hence False using REL DIFF ANTISYM *
-   by (auto simp add: antisym_def)
-  }
-  thus ?thesis by blast
-qed
-
-
-
-end (* context wo_rel *)
-
-
-
-end
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/HOL/Constructions_on_Wellorders_FP.thy	Mon Jan 20 18:24:55 2014 +0100
@@ -0,0 +1,1774 @@
+(*  Title:      HOL/Constructions_on_Wellorders_FP.thy
+    Author:     Andrei Popescu, TU Muenchen
+    Copyright   2012
+
+Constructions on wellorders (FP).
+*)
+
+header {* Constructions on Wellorders (FP) *}
+
+theory Constructions_on_Wellorders_FP
+imports Wellorder_Embedding_FP
+begin
+
+
+text {* In this section, we study basic constructions on well-orders, such as restriction to
+a set/order filter, copy via direct images, ordinal-like sum of disjoint well-orders,
+and bounded square.  We also define between well-orders
+the relations @{text "ordLeq"}, of being embedded (abbreviated @{text "\<le>o"}),
+@{text "ordLess"}, of being strictly embedded (abbreviated @{text "<o"}), and
+@{text "ordIso"}, of being isomorphic (abbreviated @{text "=o"}).  We study the
+connections between these relations, order filters, and the aforementioned constructions.
+A main result of this section is that @{text "<o"} is well-founded.  *}
+
+
+subsection {* Restriction to a set  *}
+
+
+abbreviation Restr :: "'a rel \<Rightarrow> 'a set \<Rightarrow> 'a rel"
+where "Restr r A \<equiv> r Int (A \<times> A)"
+
+
+lemma Restr_subset:
+"A \<le> B \<Longrightarrow> Restr (Restr r B) A = Restr r A"
+by blast
+
+
+lemma Restr_Field: "Restr r (Field r) = r"
+unfolding Field_def by auto
+
+
+lemma Refl_Restr: "Refl r \<Longrightarrow> Refl(Restr r A)"
+unfolding refl_on_def Field_def by auto
+
+
+lemma antisym_Restr:
+"antisym r \<Longrightarrow> antisym(Restr r A)"
+unfolding antisym_def Field_def by auto
+
+
+lemma Total_Restr:
+"Total r \<Longrightarrow> Total(Restr r A)"
+unfolding total_on_def Field_def by auto
+
+
+lemma trans_Restr:
+"trans r \<Longrightarrow> trans(Restr r A)"
+unfolding trans_def Field_def by blast
+
+
+lemma Preorder_Restr:
+"Preorder r \<Longrightarrow> Preorder(Restr r A)"
+unfolding preorder_on_def by (simp add: Refl_Restr trans_Restr)
+
+
+lemma Partial_order_Restr:
+"Partial_order r \<Longrightarrow> Partial_order(Restr r A)"
+unfolding partial_order_on_def by (simp add: Preorder_Restr antisym_Restr)
+
+
+lemma Linear_order_Restr:
+"Linear_order r \<Longrightarrow> Linear_order(Restr r A)"
+unfolding linear_order_on_def by (simp add: Partial_order_Restr Total_Restr)
+
+
+lemma Well_order_Restr:
+assumes "Well_order r"
+shows "Well_order(Restr r A)"
+proof-
+  have "Restr r A - Id \<le> r - Id" using Restr_subset by blast
+  hence "wf(Restr r A - Id)" using assms
+  using well_order_on_def wf_subset by blast
+  thus ?thesis using assms unfolding well_order_on_def
+  by (simp add: Linear_order_Restr)
+qed
+
+
+lemma Field_Restr_subset: "Field(Restr r A) \<le> A"
+by (auto simp add: Field_def)
+
+
+lemma Refl_Field_Restr:
+"Refl r \<Longrightarrow> Field(Restr r A) = (Field r) Int A"
+unfolding refl_on_def Field_def by blast
+
+
+lemma Refl_Field_Restr2:
+"\<lbrakk>Refl r; A \<le> Field r\<rbrakk> \<Longrightarrow> Field(Restr r A) = A"
+by (auto simp add: Refl_Field_Restr)
+
+
+lemma well_order_on_Restr:
+assumes WELL: "Well_order r" and SUB: "A \<le> Field r"
+shows "well_order_on A (Restr r A)"
+using assms
+using Well_order_Restr[of r A] Refl_Field_Restr2[of r A]
+     order_on_defs[of "Field r" r] by auto
+
+
+subsection {* Order filters versus restrictions and embeddings  *}
+
+
+lemma Field_Restr_ofilter:
+"\<lbrakk>Well_order r; wo_rel.ofilter r A\<rbrakk> \<Longrightarrow> Field(Restr r A) = A"
+by (auto simp add: wo_rel_def wo_rel.ofilter_def wo_rel.REFL Refl_Field_Restr2)
+
+
+lemma ofilter_Restr_under:
+assumes WELL: "Well_order r" and OF: "wo_rel.ofilter r A" and IN: "a \<in> A"
+shows "under (Restr r A) a = under r a"
+using assms wo_rel_def
+proof(auto simp add: wo_rel.ofilter_def under_def)
+  fix b assume *: "a \<in> A" and "(b,a) \<in> r"
+  hence "b \<in> under r a \<and> a \<in> Field r"
+  unfolding under_def using Field_def by fastforce
+  thus "b \<in> A" using * assms by (auto simp add: wo_rel_def wo_rel.ofilter_def)
+qed
+
+
+lemma ofilter_embed:
+assumes "Well_order r"
+shows "wo_rel.ofilter r A = (A \<le> Field r \<and> embed (Restr r A) r id)"
+proof
+  assume *: "wo_rel.ofilter r A"
+  show "A \<le> Field r \<and> embed (Restr r A) r id"
+  proof(unfold embed_def, auto)
+    fix a assume "a \<in> A" thus "a \<in> Field r" using assms *
+    by (auto simp add: wo_rel_def wo_rel.ofilter_def)
+  next
+    fix a assume "a \<in> Field (Restr r A)"
+    thus "bij_betw id (under (Restr r A) a) (under r a)" using assms *
+    by (simp add: ofilter_Restr_under Field_Restr_ofilter)
+  qed
+next
+  assume *: "A \<le> Field r \<and> embed (Restr r A) r id"
+  hence "Field(Restr r A) \<le> Field r"
+  using assms  embed_Field[of "Restr r A" r id] id_def
+        Well_order_Restr[of r] by auto
+  {fix a assume "a \<in> A"
+   hence "a \<in> Field(Restr r A)" using * assms
+   by (simp add: order_on_defs Refl_Field_Restr2)
+   hence "bij_betw id (under (Restr r A) a) (under r a)"
+   using * unfolding embed_def by auto
+   hence "under r a \<le> under (Restr r A) a"
+   unfolding bij_betw_def by auto
+   also have "\<dots> \<le> Field(Restr r A)" by (simp add: under_Field)
+   also have "\<dots> \<le> A" by (simp add: Field_Restr_subset)
+   finally have "under r a \<le> A" .
+  }
+  thus "wo_rel.ofilter r A" using assms * by (simp add: wo_rel_def wo_rel.ofilter_def)
+qed
+
+
+lemma ofilter_Restr_Int:
+assumes WELL: "Well_order r" and OFA: "wo_rel.ofilter r A"
+shows "wo_rel.ofilter (Restr r B) (A Int B)"
+proof-
+  let ?rB = "Restr r B"
+  have Well: "wo_rel r" unfolding wo_rel_def using WELL .
+  hence Refl: "Refl r" by (simp add: wo_rel.REFL)
+  hence Field: "Field ?rB = Field r Int B"
+  using Refl_Field_Restr by blast
+  have WellB: "wo_rel ?rB \<and> Well_order ?rB" using WELL
+  by (simp add: Well_order_Restr wo_rel_def)
+  (* Main proof *)
+  show ?thesis using WellB assms
+  proof(auto simp add: wo_rel.ofilter_def under_def)
+    fix a assume "a \<in> A" and *: "a \<in> B"
+    hence "a \<in> Field r" using OFA Well by (auto simp add: wo_rel.ofilter_def)
+    with * show "a \<in> Field ?rB" using Field by auto
+  next
+    fix a b assume "a \<in> A" and "(b,a) \<in> r"
+    thus "b \<in> A" using Well OFA by (auto simp add: wo_rel.ofilter_def under_def)
+  qed
+qed
+
+
+lemma ofilter_Restr_subset:
+assumes WELL: "Well_order r" and OFA: "wo_rel.ofilter r A" and SUB: "A \<le> B"
+shows "wo_rel.ofilter (Restr r B) A"
+proof-
+  have "A Int B = A" using SUB by blast
+  thus ?thesis using assms ofilter_Restr_Int[of r A B] by auto
+qed
+
+
+lemma ofilter_subset_embed:
+assumes WELL: "Well_order r" and
+        OFA: "wo_rel.ofilter r A" and OFB: "wo_rel.ofilter r B"
+shows "(A \<le> B) = (embed (Restr r A) (Restr r B) id)"
+proof-
+  let ?rA = "Restr r A"  let ?rB = "Restr r B"
+  have Well: "wo_rel r" unfolding wo_rel_def using WELL .
+  hence Refl: "Refl r" by (simp add: wo_rel.REFL)
+  hence FieldA: "Field ?rA = Field r Int A"
+  using Refl_Field_Restr by blast
+  have FieldB: "Field ?rB = Field r Int B"
+  using Refl Refl_Field_Restr by blast
+  have WellA: "wo_rel ?rA \<and> Well_order ?rA" using WELL
+  by (simp add: Well_order_Restr wo_rel_def)
+  have WellB: "wo_rel ?rB \<and> Well_order ?rB" using WELL
+  by (simp add: Well_order_Restr wo_rel_def)
+  (* Main proof *)
+  show ?thesis
+  proof
+    assume *: "A \<le> B"
+    hence "wo_rel.ofilter (Restr r B) A" using assms
+    by (simp add: ofilter_Restr_subset)
+    hence "embed (Restr ?rB A) (Restr r B) id"
+    using WellB ofilter_embed[of "?rB" A] by auto
+    thus "embed (Restr r A) (Restr r B) id"
+    using * by (simp add: Restr_subset)
+  next
+    assume *: "embed (Restr r A) (Restr r B) id"
+    {fix a assume **: "a \<in> A"
+     hence "a \<in> Field r" using Well OFA by (auto simp add: wo_rel.ofilter_def)
+     with ** FieldA have "a \<in> Field ?rA" by auto
+     hence "a \<in> Field ?rB" using * WellA embed_Field[of ?rA ?rB id] by auto
+     hence "a \<in> B" using FieldB by auto
+    }
+    thus "A \<le> B" by blast
+  qed
+qed
+
+
+lemma ofilter_subset_embedS_iso:
+assumes WELL: "Well_order r" and
+        OFA: "wo_rel.ofilter r A" and OFB: "wo_rel.ofilter r B"
+shows "((A < B) = (embedS (Restr r A) (Restr r B) id)) \<and>
+       ((A = B) = (iso (Restr r A) (Restr r B) id))"
+proof-
+  let ?rA = "Restr r A"  let ?rB = "Restr r B"
+  have Well: "wo_rel r" unfolding wo_rel_def using WELL .
+  hence Refl: "Refl r" by (simp add: wo_rel.REFL)
+  hence "Field ?rA = Field r Int A"
+  using Refl_Field_Restr by blast
+  hence FieldA: "Field ?rA = A" using OFA Well
+  by (auto simp add: wo_rel.ofilter_def)
+  have "Field ?rB = Field r Int B"
+  using Refl Refl_Field_Restr by blast
+  hence FieldB: "Field ?rB = B" using OFB Well
+  by (auto simp add: wo_rel.ofilter_def)
+  (* Main proof *)
+  show ?thesis unfolding embedS_def iso_def
+  using assms ofilter_subset_embed[of r A B]
+        FieldA FieldB bij_betw_id_iff[of A B] by auto
+qed
+
+
+lemma ofilter_subset_embedS:
+assumes WELL: "Well_order r" and
+        OFA: "wo_rel.ofilter r A" and OFB: "wo_rel.ofilter r B"
+shows "(A < B) = embedS (Restr r A) (Restr r B) id"
+using assms by (simp add: ofilter_subset_embedS_iso)
+
+
+lemma embed_implies_iso_Restr:
+assumes WELL: "Well_order r" and WELL': "Well_order r'" and
+        EMB: "embed r' r f"
+shows "iso r' (Restr r (f ` (Field r'))) f"
+proof-
+  let ?A' = "Field r'"
+  let ?r'' = "Restr r (f ` ?A')"
+  have 0: "Well_order ?r''" using WELL Well_order_Restr by blast
+  have 1: "wo_rel.ofilter r (f ` ?A')" using assms embed_Field_ofilter  by blast
+  hence "Field ?r'' = f ` (Field r')" using WELL Field_Restr_ofilter by blast
+  hence "bij_betw f ?A' (Field ?r'')"
+  using EMB embed_inj_on WELL' unfolding bij_betw_def by blast
+  moreover
+  {have "\<forall>a b. (a,b) \<in> r' \<longrightarrow> a \<in> Field r' \<and> b \<in> Field r'"
+   unfolding Field_def by auto
+   hence "compat r' ?r'' f"
+   using assms embed_iff_compat_inj_on_ofilter
+   unfolding compat_def by blast
+  }
+  ultimately show ?thesis using WELL' 0 iso_iff3 by blast
+qed
+
+
+subsection {* The strict inclusion on proper ofilters is well-founded *}
+
+
+definition ofilterIncl :: "'a rel \<Rightarrow> 'a set rel"
+where
+"ofilterIncl r \<equiv> {(A,B). wo_rel.ofilter r A \<and> A \<noteq> Field r \<and>
+                         wo_rel.ofilter r B \<and> B \<noteq> Field r \<and> A < B}"
+
+
+lemma wf_ofilterIncl:
+assumes WELL: "Well_order r"
+shows "wf(ofilterIncl r)"
+proof-
+  have Well: "wo_rel r" using WELL by (simp add: wo_rel_def)
+  hence Lo: "Linear_order r" by (simp add: wo_rel.LIN)
+  let ?h = "(\<lambda> A. wo_rel.suc r A)"
+  let ?rS = "r - Id"
+  have "wf ?rS" using WELL by (simp add: order_on_defs)
+  moreover
+  have "compat (ofilterIncl r) ?rS ?h"
+  proof(unfold compat_def ofilterIncl_def,
+        intro allI impI, simp, elim conjE)
+    fix A B
+    assume *: "wo_rel.ofilter r A" "A \<noteq> Field r" and
+           **: "wo_rel.ofilter r B" "B \<noteq> Field r" and ***: "A < B"
+    then obtain a and b where 0: "a \<in> Field r \<and> b \<in> Field r" and
+                         1: "A = underS r a \<and> B = underS r b"
+    using Well by (auto simp add: wo_rel.ofilter_underS_Field)
+    hence "a \<noteq> b" using *** by auto
+    moreover
+    have "(a,b) \<in> r" using 0 1 Lo ***
+    by (auto simp add: underS_incl_iff)
+    moreover
+    have "a = wo_rel.suc r A \<and> b = wo_rel.suc r B"
+    using Well 0 1 by (simp add: wo_rel.suc_underS)
+    ultimately
+    show "(wo_rel.suc r A, wo_rel.suc r B) \<in> r \<and> wo_rel.suc r A \<noteq> wo_rel.suc r B"
+    by simp
+  qed
+  ultimately show "wf (ofilterIncl r)" by (simp add: compat_wf)
+qed
+
+
+
+subsection {* Ordering the well-orders by existence of embeddings *}
+
+
+text {* We define three relations between well-orders:
+\begin{itemize}
+\item @{text "ordLeq"}, of being embedded (abbreviated @{text "\<le>o"});
+\item @{text "ordLess"}, of being strictly embedded (abbreviated @{text "<o"});
+\item @{text "ordIso"}, of being isomorphic (abbreviated @{text "=o"}).
+\end{itemize}
+%
+The prefix "ord" and the index "o" in these names stand for "ordinal-like".
+These relations shall be proved to be inter-connected in a similar fashion as the trio
+@{text "\<le>"}, @{text "<"}, @{text "="} associated to a total order on a set.
+*}
+
+
+definition ordLeq :: "('a rel * 'a' rel) set"
+where
+"ordLeq = {(r,r'). Well_order r \<and> Well_order r' \<and> (\<exists>f. embed r r' f)}"
+
+
+abbreviation ordLeq2 :: "'a rel \<Rightarrow> 'a' rel \<Rightarrow> bool" (infix "<=o" 50)
+where "r <=o r' \<equiv> (r,r') \<in> ordLeq"
+
+
+abbreviation ordLeq3 :: "'a rel \<Rightarrow> 'a' rel \<Rightarrow> bool" (infix "\<le>o" 50)
+where "r \<le>o r' \<equiv> r <=o r'"
+
+
+definition ordLess :: "('a rel * 'a' rel) set"
+where
+"ordLess = {(r,r'). Well_order r \<and> Well_order r' \<and> (\<exists>f. embedS r r' f)}"
+
+abbreviation ordLess2 :: "'a rel \<Rightarrow> 'a' rel \<Rightarrow> bool" (infix "<o" 50)
+where "r <o r' \<equiv> (r,r') \<in> ordLess"
+
+
+definition ordIso :: "('a rel * 'a' rel) set"
+where
+"ordIso = {(r,r'). Well_order r \<and> Well_order r' \<and> (\<exists>f. iso r r' f)}"
+
+abbreviation ordIso2 :: "'a rel \<Rightarrow> 'a' rel \<Rightarrow> bool" (infix "=o" 50)
+where "r =o r' \<equiv> (r,r') \<in> ordIso"
+
+
+lemmas ordRels_def = ordLeq_def ordLess_def ordIso_def
+
+lemma ordLeq_Well_order_simp:
+assumes "r \<le>o r'"
+shows "Well_order r \<and> Well_order r'"
+using assms unfolding ordLeq_def by simp
+
+
+text{* Notice that the relations @{text "\<le>o"}, @{text "<o"}, @{text "=o"} connect well-orders
+on potentially {\em distinct} types. However, some of the lemmas below, including the next one,
+restrict implicitly the type of these relations to @{text "(('a rel) * ('a rel)) set"} , i.e.,
+to @{text "'a rel rel"}.  *}
+
+
+lemma ordLeq_reflexive:
+"Well_order r \<Longrightarrow> r \<le>o r"
+unfolding ordLeq_def using id_embed[of r] by blast
+
+
+lemma ordLeq_transitive[trans]:
+assumes *: "r \<le>o r'" and **: "r' \<le>o r''"
+shows "r \<le>o r''"
+proof-
+  obtain f and f'
+  where 1: "Well_order r \<and> Well_order r' \<and> Well_order r''" and
+        "embed r r' f" and "embed r' r'' f'"
+  using * ** unfolding ordLeq_def by blast
+  hence "embed r r'' (f' o f)"
+  using comp_embed[of r r' f r'' f'] by auto
+  thus "r \<le>o r''" unfolding ordLeq_def using 1 by auto
+qed
+
+
+lemma ordLeq_total:
+"\<lbrakk>Well_order r; Well_order r'\<rbrakk> \<Longrightarrow> r \<le>o r' \<or> r' \<le>o r"
+unfolding ordLeq_def using wellorders_totally_ordered by blast
+
+
+lemma ordIso_reflexive:
+"Well_order r \<Longrightarrow> r =o r"
+unfolding ordIso_def using id_iso[of r] by blast
+
+
+lemma ordIso_transitive[trans]:
+assumes *: "r =o r'" and **: "r' =o r''"
+shows "r =o r''"
+proof-
+  obtain f and f'
+  where 1: "Well_order r \<and> Well_order r' \<and> Well_order r''" and
+        "iso r r' f" and 3: "iso r' r'' f'"
+  using * ** unfolding ordIso_def by auto
+  hence "iso r r'' (f' o f)"
+  using comp_iso[of r r' f r'' f'] by auto
+  thus "r =o r''" unfolding ordIso_def using 1 by auto
+qed
+
+
+lemma ordIso_symmetric:
+assumes *: "r =o r'"
+shows "r' =o r"
+proof-
+  obtain f where 1: "Well_order r \<and> Well_order r'" and
+                 2: "embed r r' f \<and> bij_betw f (Field r) (Field r')"
+  using * by (auto simp add: ordIso_def iso_def)
+  let ?f' = "inv_into (Field r) f"
+  have "embed r' r ?f' \<and> bij_betw ?f' (Field r') (Field r)"
+  using 1 2 by (simp add: bij_betw_inv_into inv_into_Field_embed_bij_betw)
+  thus "r' =o r" unfolding ordIso_def using 1 by (auto simp add: iso_def)
+qed
+
+
+lemma ordLeq_ordLess_trans[trans]:
+assumes "r \<le>o r'" and " r' <o r''"
+shows "r <o r''"
+proof-
+  have "Well_order r \<and> Well_order r''"
+  using assms unfolding ordLeq_def ordLess_def by auto
+  thus ?thesis using assms unfolding ordLeq_def ordLess_def
+  using embed_comp_embedS by blast
+qed
+
+
+lemma ordLess_ordLeq_trans[trans]:
+assumes "r <o r'" and " r' \<le>o r''"
+shows "r <o r''"
+proof-
+  have "Well_order r \<and> Well_order r''"
+  using assms unfolding ordLeq_def ordLess_def by auto
+  thus ?thesis using assms unfolding ordLeq_def ordLess_def
+  using embedS_comp_embed by blast
+qed
+
+
+lemma ordLeq_ordIso_trans[trans]:
+assumes "r \<le>o r'" and " r' =o r''"
+shows "r \<le>o r''"
+proof-
+  have "Well_order r \<and> Well_order r''"
+  using assms unfolding ordLeq_def ordIso_def by auto
+  thus ?thesis using assms unfolding ordLeq_def ordIso_def
+  using embed_comp_iso by blast
+qed
+
+
+lemma ordIso_ordLeq_trans[trans]:
+assumes "r =o r'" and " r' \<le>o r''"
+shows "r \<le>o r''"
+proof-
+  have "Well_order r \<and> Well_order r''"
+  using assms unfolding ordLeq_def ordIso_def by auto
+  thus ?thesis using assms unfolding ordLeq_def ordIso_def
+  using iso_comp_embed by blast
+qed
+
+
+lemma ordLess_ordIso_trans[trans]:
+assumes "r <o r'" and " r' =o r''"
+shows "r <o r''"
+proof-
+  have "Well_order r \<and> Well_order r''"
+  using assms unfolding ordLess_def ordIso_def by auto
+  thus ?thesis using assms unfolding ordLess_def ordIso_def
+  using embedS_comp_iso by blast
+qed
+
+
+lemma ordIso_ordLess_trans[trans]:
+assumes "r =o r'" and " r' <o r''"
+shows "r <o r''"
+proof-
+  have "Well_order r \<and> Well_order r''"
+  using assms unfolding ordLess_def ordIso_def by auto
+  thus ?thesis using assms unfolding ordLess_def ordIso_def
+  using iso_comp_embedS by blast
+qed
+
+
+lemma ordLess_not_embed: