diff --git a/src/HOL/Filter.thy b/src/HOL/Filter.thy
--- a/src/HOL/Filter.thy
+++ b/src/HOL/Filter.thy
@@ -1,1996 +1,1998 @@
 (*  Title:      HOL/Filter.thy
     Author:     Brian Huffman
     Author:     Johannes Hölzl
 *)
 
 section \<open>Filters on predicates\<close>
 
 theory Filter
 imports Set_Interval Lifting_Set
 begin
 
 subsection \<open>Filters\<close>
 
 text \<open>
   This definition also allows non-proper filters.
 \<close>
 
 locale is_filter =
   fixes F :: "('a \<Rightarrow> bool) \<Rightarrow> bool"
   assumes True: "F (\<lambda>x. True)"
   assumes conj: "F (\<lambda>x. P x) \<Longrightarrow> F (\<lambda>x. Q x) \<Longrightarrow> F (\<lambda>x. P x \<and> Q x)"
   assumes mono: "\<forall>x. P x \<longrightarrow> Q x \<Longrightarrow> F (\<lambda>x. P x) \<Longrightarrow> F (\<lambda>x. Q x)"
 
 typedef 'a filter = "{F :: ('a \<Rightarrow> bool) \<Rightarrow> bool. is_filter F}"
 proof
   show "(\<lambda>x. True) \<in> ?filter" by (auto intro: is_filter.intro)
 qed
 
 lemma is_filter_Rep_filter: "is_filter (Rep_filter F)"
   using Rep_filter [of F] by simp
 
 lemma Abs_filter_inverse':
   assumes "is_filter F" shows "Rep_filter (Abs_filter F) = F"
   using assms by (simp add: Abs_filter_inverse)
 
 
 subsubsection \<open>Eventually\<close>
 
 definition eventually :: "('a \<Rightarrow> bool) \<Rightarrow> 'a filter \<Rightarrow> bool"
   where "eventually P F \<longleftrightarrow> Rep_filter F P"
 
 syntax
   "_eventually" :: "pttrn => 'a filter => bool => bool"  ("(3\<forall>\<^sub>F _ in _./ _)" [0, 0, 10] 10)
 translations
   "\<forall>\<^sub>Fx in F. P" == "CONST eventually (\<lambda>x. P) F"
 
 lemma eventually_Abs_filter:
   assumes "is_filter F" shows "eventually P (Abs_filter F) = F P"
   unfolding eventually_def using assms by (simp add: Abs_filter_inverse)
 
 lemma filter_eq_iff:
   shows "F = F' \<longleftrightarrow> (\<forall>P. eventually P F = eventually P F')"
   unfolding Rep_filter_inject [symmetric] fun_eq_iff eventually_def ..
 
 lemma eventually_True [simp]: "eventually (\<lambda>x. True) F"
   unfolding eventually_def
   by (rule is_filter.True [OF is_filter_Rep_filter])
 
 lemma always_eventually: "\<forall>x. P x \<Longrightarrow> eventually P F"
 proof -
   assume "\<forall>x. P x" hence "P = (\<lambda>x. True)" by (simp add: ext)
   thus "eventually P F" by simp
 qed
 
 lemma eventuallyI: "(\<And>x. P x) \<Longrightarrow> eventually P F"
   by (auto intro: always_eventually)
 
 lemma eventually_mono:
   "\<lbrakk>eventually P F; \<And>x. P x \<Longrightarrow> Q x\<rbrakk> \<Longrightarrow> eventually Q F"
   unfolding eventually_def
   by (blast intro: is_filter.mono [OF is_filter_Rep_filter])
 
 lemma eventually_conj:
   assumes P: "eventually (\<lambda>x. P x) F"
   assumes Q: "eventually (\<lambda>x. Q x) F"
   shows "eventually (\<lambda>x. P x \<and> Q x) F"
   using assms unfolding eventually_def
   by (rule is_filter.conj [OF is_filter_Rep_filter])
 
 lemma eventually_mp:
   assumes "eventually (\<lambda>x. P x \<longrightarrow> Q x) F"
   assumes "eventually (\<lambda>x. P x) F"
   shows "eventually (\<lambda>x. Q x) F"
 proof -
   have "eventually (\<lambda>x. (P x \<longrightarrow> Q x) \<and> P x) F"
     using assms by (rule eventually_conj)
   then show ?thesis
     by (blast intro: eventually_mono)
 qed
 
 lemma eventually_rev_mp:
   assumes "eventually (\<lambda>x. P x) F"
   assumes "eventually (\<lambda>x. P x \<longrightarrow> Q x) F"
   shows "eventually (\<lambda>x. Q x) F"
 using assms(2) assms(1) by (rule eventually_mp)
 
 lemma eventually_conj_iff:
   "eventually (\<lambda>x. P x \<and> Q x) F \<longleftrightarrow> eventually P F \<and> eventually Q F"
   by (auto intro: eventually_conj elim: eventually_rev_mp)
 
 lemma eventually_elim2:
   assumes "eventually (\<lambda>i. P i) F"
   assumes "eventually (\<lambda>i. Q i) F"
   assumes "\<And>i. P i \<Longrightarrow> Q i \<Longrightarrow> R i"
   shows "eventually (\<lambda>i. R i) F"
   using assms by (auto elim!: eventually_rev_mp)
 
 lemma eventually_ball_finite_distrib:
   "finite A \<Longrightarrow> (eventually (\<lambda>x. \<forall>y\<in>A. P x y) net) \<longleftrightarrow> (\<forall>y\<in>A. eventually (\<lambda>x. P x y) net)"
   by (induction A rule: finite_induct) (auto simp: eventually_conj_iff)
 
 lemma eventually_ball_finite:
   "finite A \<Longrightarrow> \<forall>y\<in>A. eventually (\<lambda>x. P x y) net \<Longrightarrow> eventually (\<lambda>x. \<forall>y\<in>A. P x y) net"
   by (auto simp: eventually_ball_finite_distrib)
 
 lemma eventually_all_finite:
   fixes P :: "'a \<Rightarrow> 'b::finite \<Rightarrow> bool"
   assumes "\<And>y. eventually (\<lambda>x. P x y) net"
   shows "eventually (\<lambda>x. \<forall>y. P x y) net"
 using eventually_ball_finite [of UNIV P] assms by simp
 
 lemma eventually_ex: "(\<forall>\<^sub>Fx in F. \<exists>y. P x y) \<longleftrightarrow> (\<exists>Y. \<forall>\<^sub>Fx in F. P x (Y x))"
 proof
   assume "\<forall>\<^sub>Fx in F. \<exists>y. P x y"
   then have "\<forall>\<^sub>Fx in F. P x (SOME y. P x y)"
     by (auto intro: someI_ex eventually_mono)
   then show "\<exists>Y. \<forall>\<^sub>Fx in F. P x (Y x)"
     by auto
 qed (auto intro: eventually_mono)
 
 lemma not_eventually_impI: "eventually P F \<Longrightarrow> \<not> eventually Q F \<Longrightarrow> \<not> eventually (\<lambda>x. P x \<longrightarrow> Q x) F"
   by (auto intro: eventually_mp)
 
 lemma not_eventuallyD: "\<not> eventually P F \<Longrightarrow> \<exists>x. \<not> P x"
   by (metis always_eventually)
 
 lemma eventually_subst:
   assumes "eventually (\<lambda>n. P n = Q n) F"
   shows "eventually P F = eventually Q F" (is "?L = ?R")
 proof -
   from assms have "eventually (\<lambda>x. P x \<longrightarrow> Q x) F"
       and "eventually (\<lambda>x. Q x \<longrightarrow> P x) F"
     by (auto elim: eventually_mono)
   then show ?thesis by (auto elim: eventually_elim2)
 qed
 
 subsection \<open> Frequently as dual to eventually \<close>
 
 definition frequently :: "('a \<Rightarrow> bool) \<Rightarrow> 'a filter \<Rightarrow> bool"
   where "frequently P F \<longleftrightarrow> \<not> eventually (\<lambda>x. \<not> P x) F"
 
 syntax
   "_frequently" :: "pttrn \<Rightarrow> 'a filter \<Rightarrow> bool \<Rightarrow> bool"  ("(3\<exists>\<^sub>F _ in _./ _)" [0, 0, 10] 10)
 translations
   "\<exists>\<^sub>Fx in F. P" == "CONST frequently (\<lambda>x. P) F"
 
 lemma not_frequently_False [simp]: "\<not> (\<exists>\<^sub>Fx in F. False)"
   by (simp add: frequently_def)
 
 lemma frequently_ex: "\<exists>\<^sub>Fx in F. P x \<Longrightarrow> \<exists>x. P x"
   by (auto simp: frequently_def dest: not_eventuallyD)
 
 lemma frequentlyE: assumes "frequently P F" obtains x where "P x"
   using frequently_ex[OF assms] by auto
 
 lemma frequently_mp:
   assumes ev: "\<forall>\<^sub>Fx in F. P x \<longrightarrow> Q x" and P: "\<exists>\<^sub>Fx in F. P x" shows "\<exists>\<^sub>Fx in F. Q x"
 proof -
   from ev have "eventually (\<lambda>x. \<not> Q x \<longrightarrow> \<not> P x) F"
     by (rule eventually_rev_mp) (auto intro!: always_eventually)
   from eventually_mp[OF this] P show ?thesis
     by (auto simp: frequently_def)
 qed
 
 lemma frequently_rev_mp:
   assumes "\<exists>\<^sub>Fx in F. P x"
   assumes "\<forall>\<^sub>Fx in F. P x \<longrightarrow> Q x"
   shows "\<exists>\<^sub>Fx in F. Q x"
 using assms(2) assms(1) by (rule frequently_mp)
 
 lemma frequently_mono: "(\<forall>x. P x \<longrightarrow> Q x) \<Longrightarrow> frequently P F \<Longrightarrow> frequently Q F"
   using frequently_mp[of P Q] by (simp add: always_eventually)
 
 lemma frequently_elim1: "\<exists>\<^sub>Fx in F. P x \<Longrightarrow> (\<And>i. P i \<Longrightarrow> Q i) \<Longrightarrow> \<exists>\<^sub>Fx in F. Q x"
   by (metis frequently_mono)
 
 lemma frequently_disj_iff: "(\<exists>\<^sub>Fx in F. P x \<or> Q x) \<longleftrightarrow> (\<exists>\<^sub>Fx in F. P x) \<or> (\<exists>\<^sub>Fx in F. Q x)"
   by (simp add: frequently_def eventually_conj_iff)
 
 lemma frequently_disj: "\<exists>\<^sub>Fx in F. P x \<Longrightarrow> \<exists>\<^sub>Fx in F. Q x \<Longrightarrow> \<exists>\<^sub>Fx in F. P x \<or> Q x"
   by (simp add: frequently_disj_iff)
 
 lemma frequently_bex_finite_distrib:
   assumes "finite A" shows "(\<exists>\<^sub>Fx in F. \<exists>y\<in>A. P x y) \<longleftrightarrow> (\<exists>y\<in>A. \<exists>\<^sub>Fx in F. P x y)"
   using assms by induction (auto simp: frequently_disj_iff)
 
 lemma frequently_bex_finite: "finite A \<Longrightarrow> \<exists>\<^sub>Fx in F. \<exists>y\<in>A. P x y \<Longrightarrow> \<exists>y\<in>A. \<exists>\<^sub>Fx in F. P x y"
   by (simp add: frequently_bex_finite_distrib)
 
 lemma frequently_all: "(\<exists>\<^sub>Fx in F. \<forall>y. P x y) \<longleftrightarrow> (\<forall>Y. \<exists>\<^sub>Fx in F. P x (Y x))"
   using eventually_ex[of "\<lambda>x y. \<not> P x y" F] by (simp add: frequently_def)
 
 lemma
   shows not_eventually: "\<not> eventually P F \<longleftrightarrow> (\<exists>\<^sub>Fx in F. \<not> P x)"
     and not_frequently: "\<not> frequently P F \<longleftrightarrow> (\<forall>\<^sub>Fx in F. \<not> P x)"
   by (auto simp: frequently_def)
 
 lemma frequently_imp_iff:
   "(\<exists>\<^sub>Fx in F. P x \<longrightarrow> Q x) \<longleftrightarrow> (eventually P F \<longrightarrow> frequently Q F)"
   unfolding imp_conv_disj frequently_disj_iff not_eventually[symmetric] ..
 
 lemma eventually_frequently_const_simps:
   "(\<exists>\<^sub>Fx in F. P x \<and> C) \<longleftrightarrow> (\<exists>\<^sub>Fx in F. P x) \<and> C"
   "(\<exists>\<^sub>Fx in F. C \<and> P x) \<longleftrightarrow> C \<and> (\<exists>\<^sub>Fx in F. P x)"
   "(\<forall>\<^sub>Fx in F. P x \<or> C) \<longleftrightarrow> (\<forall>\<^sub>Fx in F. P x) \<or> C"
   "(\<forall>\<^sub>Fx in F. C \<or> P x) \<longleftrightarrow> C \<or> (\<forall>\<^sub>Fx in F. P x)"
   "(\<forall>\<^sub>Fx in F. P x \<longrightarrow> C) \<longleftrightarrow> ((\<exists>\<^sub>Fx in F. P x) \<longrightarrow> C)"
   "(\<forall>\<^sub>Fx in F. C \<longrightarrow> P x) \<longleftrightarrow> (C \<longrightarrow> (\<forall>\<^sub>Fx in F. P x))"
   by (cases C; simp add: not_frequently)+
 
 lemmas eventually_frequently_simps =
   eventually_frequently_const_simps
   not_eventually
   eventually_conj_iff
   eventually_ball_finite_distrib
   eventually_ex
   not_frequently
   frequently_disj_iff
   frequently_bex_finite_distrib
   frequently_all
   frequently_imp_iff
 
 ML \<open>
   fun eventually_elim_tac facts =
     CONTEXT_SUBGOAL (fn (goal, i) => fn (ctxt, st) =>
       let
         val mp_facts = facts RL @{thms eventually_rev_mp}
         val rule =
           @{thm eventuallyI}
           |> fold (fn mp_fact => fn th => th RS mp_fact) mp_facts
           |> funpow (length facts) (fn th => @{thm impI} RS th)
         val cases_prop =
           Thm.prop_of (Rule_Cases.internalize_params (rule RS Goal.init (Thm.cterm_of ctxt goal)))
         val cases = Rule_Cases.make_common ctxt cases_prop [(("elim", []), [])]
       in CONTEXT_CASES cases (resolve_tac ctxt [rule] i) (ctxt, st) end)
 \<close>
 
 method_setup eventually_elim = \<open>
   Scan.succeed (fn _ => CONTEXT_METHOD (fn facts => eventually_elim_tac facts 1))
 \<close> "elimination of eventually quantifiers"
 
 subsubsection \<open>Finer-than relation\<close>
 
 text \<open>\<^term>\<open>F \<le> F'\<close> means that filter \<^term>\<open>F\<close> is finer than
 filter \<^term>\<open>F'\<close>.\<close>
 
 instantiation filter :: (type) complete_lattice
 begin
 
 definition le_filter_def:
   "F \<le> F' \<longleftrightarrow> (\<forall>P. eventually P F' \<longrightarrow> eventually P F)"
 
 definition
   "(F :: 'a filter) < F' \<longleftrightarrow> F \<le> F' \<and> \<not> F' \<le> F"
 
 definition
   "top = Abs_filter (\<lambda>P. \<forall>x. P x)"
 
 definition
   "bot = Abs_filter (\<lambda>P. True)"
 
 definition
   "sup F F' = Abs_filter (\<lambda>P. eventually P F \<and> eventually P F')"
 
 definition
   "inf F F' = Abs_filter
       (\<lambda>P. \<exists>Q R. eventually Q F \<and> eventually R F' \<and> (\<forall>x. Q x \<and> R x \<longrightarrow> P x))"
 
 definition
   "Sup S = Abs_filter (\<lambda>P. \<forall>F\<in>S. eventually P F)"
 
 definition
   "Inf S = Sup {F::'a filter. \<forall>F'\<in>S. F \<le> F'}"
 
 lemma eventually_top [simp]: "eventually P top \<longleftrightarrow> (\<forall>x. P x)"
   unfolding top_filter_def
   by (rule eventually_Abs_filter, rule is_filter.intro, auto)
 
 lemma eventually_bot [simp]: "eventually P bot"
   unfolding bot_filter_def
   by (subst eventually_Abs_filter, rule is_filter.intro, auto)
 
 lemma eventually_sup:
   "eventually P (sup F F') \<longleftrightarrow> eventually P F \<and> eventually P F'"
   unfolding sup_filter_def
   by (rule eventually_Abs_filter, rule is_filter.intro)
      (auto elim!: eventually_rev_mp)
 
 lemma eventually_inf:
   "eventually P (inf F F') \<longleftrightarrow>
    (\<exists>Q R. eventually Q F \<and> eventually R F' \<and> (\<forall>x. Q x \<and> R x \<longrightarrow> P x))"
   unfolding inf_filter_def
   apply (rule eventually_Abs_filter [OF is_filter.intro])
   apply (blast intro: eventually_True)
    apply (force elim!: eventually_conj)+
   done
 
 lemma eventually_Sup:
   "eventually P (Sup S) \<longleftrightarrow> (\<forall>F\<in>S. eventually P F)"
   unfolding Sup_filter_def
   apply (rule eventually_Abs_filter [OF is_filter.intro])
   apply (auto intro: eventually_conj elim!: eventually_rev_mp)
   done
 
 instance proof
   fix F F' F'' :: "'a filter" and S :: "'a filter set"
   { show "F < F' \<longleftrightarrow> F \<le> F' \<and> \<not> F' \<le> F"
     by (rule less_filter_def) }
   { show "F \<le> F"
     unfolding le_filter_def by simp }
   { assume "F \<le> F'" and "F' \<le> F''" thus "F \<le> F''"
     unfolding le_filter_def by simp }
   { assume "F \<le> F'" and "F' \<le> F" thus "F = F'"
     unfolding le_filter_def filter_eq_iff by fast }
   { show "inf F F' \<le> F" and "inf F F' \<le> F'"
     unfolding le_filter_def eventually_inf by (auto intro: eventually_True) }
   { assume "F \<le> F'" and "F \<le> F''" thus "F \<le> inf F' F''"
     unfolding le_filter_def eventually_inf
     by (auto intro: eventually_mono [OF eventually_conj]) }
   { show "F \<le> sup F F'" and "F' \<le> sup F F'"
     unfolding le_filter_def eventually_sup by simp_all }
   { assume "F \<le> F''" and "F' \<le> F''" thus "sup F F' \<le> F''"
     unfolding le_filter_def eventually_sup by simp }
   { assume "F'' \<in> S" thus "Inf S \<le> F''"
     unfolding le_filter_def Inf_filter_def eventually_Sup Ball_def by simp }
   { assume "\<And>F'. F' \<in> S \<Longrightarrow> F \<le> F'" thus "F \<le> Inf S"
     unfolding le_filter_def Inf_filter_def eventually_Sup Ball_def by simp }
   { assume "F \<in> S" thus "F \<le> Sup S"
     unfolding le_filter_def eventually_Sup by simp }
   { assume "\<And>F. F \<in> S \<Longrightarrow> F \<le> F'" thus "Sup S \<le> F'"
     unfolding le_filter_def eventually_Sup by simp }
   { show "Inf {} = (top::'a filter)"
     by (auto simp: top_filter_def Inf_filter_def Sup_filter_def)
       (metis (full_types) top_filter_def always_eventually eventually_top) }
   { show "Sup {} = (bot::'a filter)"
     by (auto simp: bot_filter_def Sup_filter_def) }
 qed
 
 end
 
 instance filter :: (type) distrib_lattice
 proof
   fix F G H :: "'a filter"
   show "sup F (inf G H) = inf (sup F G) (sup F H)"
   proof (rule order.antisym)
     show "inf (sup F G) (sup F H) \<le> sup F (inf G H)" 
       unfolding le_filter_def eventually_sup
     proof safe
       fix P assume 1: "eventually P F" and 2: "eventually P (inf G H)"
       from 2 obtain Q R 
         where QR: "eventually Q G" "eventually R H" "\<And>x. Q x \<Longrightarrow> R x \<Longrightarrow> P x"
         by (auto simp: eventually_inf)
       define Q' where "Q' = (\<lambda>x. Q x \<or> P x)"
       define R' where "R' = (\<lambda>x. R x \<or> P x)"
       from 1 have "eventually Q' F" 
         by (elim eventually_mono) (auto simp: Q'_def)
       moreover from 1 have "eventually R' F" 
         by (elim eventually_mono) (auto simp: R'_def)
       moreover from QR(1) have "eventually Q' G" 
         by (elim eventually_mono) (auto simp: Q'_def)
       moreover from QR(2) have "eventually R' H" 
         by (elim eventually_mono)(auto simp: R'_def)
       moreover from QR have "P x" if "Q' x" "R' x" for x 
         using that by (auto simp: Q'_def R'_def)
       ultimately show "eventually P (inf (sup F G) (sup F H))"
         by (auto simp: eventually_inf eventually_sup)
     qed
   qed (auto intro: inf.coboundedI1 inf.coboundedI2)
 qed
 
 
 lemma filter_leD:
   "F \<le> F' \<Longrightarrow> eventually P F' \<Longrightarrow> eventually P F"
   unfolding le_filter_def by simp
 
 lemma filter_leI:
   "(\<And>P. eventually P F' \<Longrightarrow> eventually P F) \<Longrightarrow> F \<le> F'"
   unfolding le_filter_def by simp
 
 lemma eventually_False:
   "eventually (\<lambda>x. False) F \<longleftrightarrow> F = bot"
   unfolding filter_eq_iff by (auto elim: eventually_rev_mp)
 
 lemma eventually_frequently: "F \<noteq> bot \<Longrightarrow> eventually P F \<Longrightarrow> frequently P F"
   using eventually_conj[of P F "\<lambda>x. \<not> P x"]
   by (auto simp add: frequently_def eventually_False)
 
 lemma eventually_frequentlyE:
   assumes "eventually P F"
   assumes "eventually (\<lambda>x. \<not> P x \<or> Q x) F" "F\<noteq>bot"
   shows "frequently Q F"
 proof -
   have "eventually Q F"
     using eventually_conj[OF assms(1,2),simplified] by (auto elim:eventually_mono)
   then show ?thesis using eventually_frequently[OF \<open>F\<noteq>bot\<close>] by auto
 qed
 
 lemma eventually_const_iff: "eventually (\<lambda>x. P) F \<longleftrightarrow> P \<or> F = bot"
   by (cases P) (auto simp: eventually_False)
 
 lemma eventually_const[simp]: "F \<noteq> bot \<Longrightarrow> eventually (\<lambda>x. P) F \<longleftrightarrow> P"
   by (simp add: eventually_const_iff)
 
 lemma frequently_const_iff: "frequently (\<lambda>x. P) F \<longleftrightarrow> P \<and> F \<noteq> bot"
   by (simp add: frequently_def eventually_const_iff)
 
 lemma frequently_const[simp]: "F \<noteq> bot \<Longrightarrow> frequently (\<lambda>x. P) F \<longleftrightarrow> P"
   by (simp add: frequently_const_iff)
 
 lemma eventually_happens: "eventually P net \<Longrightarrow> net = bot \<or> (\<exists>x. P x)"
   by (metis frequentlyE eventually_frequently)
 
 lemma eventually_happens':
   assumes "F \<noteq> bot" "eventually P F"
   shows   "\<exists>x. P x"
   using assms eventually_frequently frequentlyE by blast
 
 abbreviation (input) trivial_limit :: "'a filter \<Rightarrow> bool"
   where "trivial_limit F \<equiv> F = bot"
 
 lemma trivial_limit_def: "trivial_limit F \<longleftrightarrow> eventually (\<lambda>x. False) F"
   by (rule eventually_False [symmetric])
 
 lemma False_imp_not_eventually: "(\<forall>x. \<not> P x ) \<Longrightarrow> \<not> trivial_limit net \<Longrightarrow> \<not> eventually (\<lambda>x. P x) net"
   by (simp add: eventually_False)
 
 lemma eventually_Inf: "eventually P (Inf B) \<longleftrightarrow> (\<exists>X\<subseteq>B. finite X \<and> eventually P (Inf X))"
 proof -
   let ?F = "\<lambda>P. \<exists>X\<subseteq>B. finite X \<and> eventually P (Inf X)"
 
-  { fix P have "eventually P (Abs_filter ?F) \<longleftrightarrow> ?F P"
-    proof (rule eventually_Abs_filter is_filter.intro)+
-      show "?F (\<lambda>x. True)"
-        by (rule exI[of _ "{}"]) (simp add: le_fun_def)
-    next
-      fix P Q
-      assume "?F P" then guess X ..
-      moreover
-      assume "?F Q" then guess Y ..
-      ultimately show "?F (\<lambda>x. P x \<and> Q x)"
-        by (intro exI[of _ "X \<union> Y"])
-           (auto simp: Inf_union_distrib eventually_inf)
-    next
-      fix P Q
-      assume "?F P" then guess X ..
-      moreover assume "\<forall>x. P x \<longrightarrow> Q x"
-      ultimately show "?F Q"
-        by (intro exI[of _ X]) (auto elim: eventually_mono)
-    qed }
-  note eventually_F = this
+  have eventually_F: "eventually P (Abs_filter ?F) \<longleftrightarrow> ?F P" for P
+  proof (rule eventually_Abs_filter is_filter.intro)+
+    show "?F (\<lambda>x. True)"
+      by (rule exI[of _ "{}"]) (simp add: le_fun_def)
+  next
+    fix P Q
+    assume "?F P" "?F Q"
+    then obtain X Y where
+      "X \<subseteq> B" "finite X" "eventually P (\<Sqinter> X)"
+      "Y \<subseteq> B" "finite Y" "eventually Q (\<Sqinter> Y)" by blast
+    then show "?F (\<lambda>x. P x \<and> Q x)"
+      by (intro exI[of _ "X \<union> Y"]) (auto simp: Inf_union_distrib eventually_inf)
+  next
+    fix P Q
+    assume "?F P"
+    then obtain X where "X \<subseteq> B" "finite X" "eventually P (\<Sqinter> X)"
+      by blast
+    moreover assume "\<forall>x. P x \<longrightarrow> Q x"
+    ultimately show "?F Q"
+      by (intro exI[of _ X]) (auto elim: eventually_mono)
+  qed
 
   have "Inf B = Abs_filter ?F"
   proof (intro antisym Inf_greatest)
     show "Inf B \<le> Abs_filter ?F"
       by (auto simp: le_filter_def eventually_F dest: Inf_superset_mono)
   next
     fix F assume "F \<in> B" then show "Abs_filter ?F \<le> F"
       by (auto simp add: le_filter_def eventually_F intro!: exI[of _ "{F}"])
   qed
   then show ?thesis
     by (simp add: eventually_F)
 qed
 
 lemma eventually_INF: "eventually P (\<Sqinter>b\<in>B. F b) \<longleftrightarrow> (\<exists>X\<subseteq>B. finite X \<and> eventually P (\<Sqinter>b\<in>X. F b))"
   unfolding eventually_Inf [of P "F`B"]
   by (metis finite_imageI image_mono finite_subset_image)
 
 lemma Inf_filter_not_bot:
   fixes B :: "'a filter set"
   shows "(\<And>X. X \<subseteq> B \<Longrightarrow> finite X \<Longrightarrow> Inf X \<noteq> bot) \<Longrightarrow> Inf B \<noteq> bot"
   unfolding trivial_limit_def eventually_Inf[of _ B]
     bot_bool_def [symmetric] bot_fun_def [symmetric] bot_unique by simp
 
 lemma INF_filter_not_bot:
   fixes F :: "'i \<Rightarrow> 'a filter"
   shows "(\<And>X. X \<subseteq> B \<Longrightarrow> finite X \<Longrightarrow> (\<Sqinter>b\<in>X. F b) \<noteq> bot) \<Longrightarrow> (\<Sqinter>b\<in>B. F b) \<noteq> bot"
   unfolding trivial_limit_def eventually_INF [of _ _ B]
     bot_bool_def [symmetric] bot_fun_def [symmetric] bot_unique by simp
 
 lemma eventually_Inf_base:
   assumes "B \<noteq> {}" and base: "\<And>F G. F \<in> B \<Longrightarrow> G \<in> B \<Longrightarrow> \<exists>x\<in>B. x \<le> inf F G"
   shows "eventually P (Inf B) \<longleftrightarrow> (\<exists>b\<in>B. eventually P b)"
 proof (subst eventually_Inf, safe)
   fix X assume "finite X" "X \<subseteq> B"
   then have "\<exists>b\<in>B. \<forall>x\<in>X. b \<le> x"
   proof induct
     case empty then show ?case
       using \<open>B \<noteq> {}\<close> by auto
   next
     case (insert x X)
     then obtain b where "b \<in> B" "\<And>x. x \<in> X \<Longrightarrow> b \<le> x"
       by auto
     with \<open>insert x X \<subseteq> B\<close> base[of b x] show ?case
       by (auto intro: order_trans)
   qed
   then obtain b where "b \<in> B" "b \<le> Inf X"
     by (auto simp: le_Inf_iff)
   then show "eventually P (Inf X) \<Longrightarrow> Bex B (eventually P)"
     by (intro bexI[of _ b]) (auto simp: le_filter_def)
 qed (auto intro!: exI[of _ "{x}" for x])
 
 lemma eventually_INF_base:
   "B \<noteq> {} \<Longrightarrow> (\<And>a b. a \<in> B \<Longrightarrow> b \<in> B \<Longrightarrow> \<exists>x\<in>B. F x \<le> inf (F a) (F b)) \<Longrightarrow>
     eventually P (\<Sqinter>b\<in>B. F b) \<longleftrightarrow> (\<exists>b\<in>B. eventually P (F b))"
   by (subst eventually_Inf_base) auto
 
 lemma eventually_INF1: "i \<in> I \<Longrightarrow> eventually P (F i) \<Longrightarrow> eventually P (\<Sqinter>i\<in>I. F i)"
   using filter_leD[OF INF_lower] .
 
 lemma eventually_INF_finite:
   assumes "finite A"
   shows   "eventually P (\<Sqinter> x\<in>A. F x) \<longleftrightarrow>
              (\<exists>Q. (\<forall>x\<in>A. eventually (Q x) (F x)) \<and> (\<forall>y. (\<forall>x\<in>A. Q x y) \<longrightarrow> P y))" 
   using assms
 proof (induction arbitrary: P rule: finite_induct)
   case (insert a A P)
   from insert.hyps have [simp]: "x \<noteq> a" if "x \<in> A" for x
     using that by auto
   have "eventually P (\<Sqinter> x\<in>insert a A. F x) \<longleftrightarrow>
           (\<exists>Q R S. eventually Q (F a) \<and> (( (\<forall>x\<in>A. eventually (S x) (F x)) \<and>
             (\<forall>y. (\<forall>x\<in>A. S x y) \<longrightarrow> R y)) \<and> (\<forall>x. Q x \<and> R x \<longrightarrow> P x)))"
     unfolding ex_simps by (simp add: eventually_inf insert.IH)
   also have "\<dots> \<longleftrightarrow> (\<exists>Q. (\<forall>x\<in>insert a A. eventually (Q x) (F x)) \<and>
                            (\<forall>y. (\<forall>x\<in>insert a A. Q x y) \<longrightarrow> P y))"
   proof (safe, goal_cases)
     case (1 Q R S)
     thus ?case using 1 by (intro exI[of _ "S(a := Q)"]) auto
   next
     case (2 Q)
     show ?case
       by (rule exI[of _ "Q a"], rule exI[of _ "\<lambda>y. \<forall>x\<in>A. Q x y"],
           rule exI[of _ "Q(a := (\<lambda>_. True))"]) (use 2 in auto)
   qed
   finally show ?case .
 qed auto
 
 subsubsection \<open>Map function for filters\<close>
 
 definition filtermap :: "('a \<Rightarrow> 'b) \<Rightarrow> 'a filter \<Rightarrow> 'b filter"
   where "filtermap f F = Abs_filter (\<lambda>P. eventually (\<lambda>x. P (f x)) F)"
 
 lemma eventually_filtermap:
   "eventually P (filtermap f F) = eventually (\<lambda>x. P (f x)) F"
   unfolding filtermap_def
   apply (rule eventually_Abs_filter [OF is_filter.intro])
   apply (auto elim!: eventually_rev_mp)
   done
 
 lemma filtermap_ident: "filtermap (\<lambda>x. x) F = F"
   by (simp add: filter_eq_iff eventually_filtermap)
 
 lemma filtermap_filtermap:
   "filtermap f (filtermap g F) = filtermap (\<lambda>x. f (g x)) F"
   by (simp add: filter_eq_iff eventually_filtermap)
 
 lemma filtermap_mono: "F \<le> F' \<Longrightarrow> filtermap f F \<le> filtermap f F'"
   unfolding le_filter_def eventually_filtermap by simp
 
 lemma filtermap_bot [simp]: "filtermap f bot = bot"
   by (simp add: filter_eq_iff eventually_filtermap)
 
 lemma filtermap_bot_iff: "filtermap f F = bot \<longleftrightarrow> F = bot"
   by (simp add: trivial_limit_def eventually_filtermap)
 
 lemma filtermap_sup: "filtermap f (sup F1 F2) = sup (filtermap f F1) (filtermap f F2)"
   by (simp add: filter_eq_iff eventually_filtermap eventually_sup)
 
 lemma filtermap_SUP: "filtermap f (\<Squnion>b\<in>B. F b) = (\<Squnion>b\<in>B. filtermap f (F b))"
   by (simp add: filter_eq_iff eventually_Sup eventually_filtermap)
 
 lemma filtermap_inf: "filtermap f (inf F1 F2) \<le> inf (filtermap f F1) (filtermap f F2)"
   by (intro inf_greatest filtermap_mono inf_sup_ord)
 
 lemma filtermap_INF: "filtermap f (\<Sqinter>b\<in>B. F b) \<le> (\<Sqinter>b\<in>B. filtermap f (F b))"
   by (rule INF_greatest, rule filtermap_mono, erule INF_lower)
 
 
 subsubsection \<open>Contravariant map function for filters\<close>
 
 definition filtercomap :: "('a \<Rightarrow> 'b) \<Rightarrow> 'b filter \<Rightarrow> 'a filter" where
   "filtercomap f F = Abs_filter (\<lambda>P. \<exists>Q. eventually Q F \<and> (\<forall>x. Q (f x) \<longrightarrow> P x))"
 
 lemma eventually_filtercomap:
   "eventually P (filtercomap f F) \<longleftrightarrow> (\<exists>Q. eventually Q F \<and> (\<forall>x. Q (f x) \<longrightarrow> P x))"
   unfolding filtercomap_def
 proof (intro eventually_Abs_filter, unfold_locales, goal_cases)
   case 1
   show ?case by (auto intro!: exI[of _ "\<lambda>_. True"])
 next
   case (2 P Q)
-  from 2(1) guess P' by (elim exE conjE) note P' = this
-  from 2(2) guess Q' by (elim exE conjE) note Q' = this
+  then obtain P' Q' where P'Q':
+    "eventually P' F" "\<forall>x. P' (f x) \<longrightarrow> P x"
+    "eventually Q' F" "\<forall>x. Q' (f x) \<longrightarrow> Q x"
+    by (elim exE conjE)
   show ?case
-    by (rule exI[of _ "\<lambda>x. P' x \<and> Q' x"])
-       (insert P' Q', auto intro!: eventually_conj)
+    by (rule exI[of _ "\<lambda>x. P' x \<and> Q' x"]) (use P'Q' in \<open>auto intro!: eventually_conj\<close>)
 next
   case (3 P Q)
   thus ?case by blast
 qed
 
 lemma filtercomap_ident: "filtercomap (\<lambda>x. x) F = F"
   by (auto simp: filter_eq_iff eventually_filtercomap elim!: eventually_mono)
 
 lemma filtercomap_filtercomap: "filtercomap f (filtercomap g F) = filtercomap (\<lambda>x. g (f x)) F"
   unfolding filter_eq_iff by (auto simp: eventually_filtercomap)
   
 lemma filtercomap_mono: "F \<le> F' \<Longrightarrow> filtercomap f F \<le> filtercomap f F'"
   by (auto simp: eventually_filtercomap le_filter_def)
 
 lemma filtercomap_bot [simp]: "filtercomap f bot = bot"
   by (auto simp: filter_eq_iff eventually_filtercomap)
 
 lemma filtercomap_top [simp]: "filtercomap f top = top"
   by (auto simp: filter_eq_iff eventually_filtercomap)
 
 lemma filtercomap_inf: "filtercomap f (inf F1 F2) = inf (filtercomap f F1) (filtercomap f F2)"
   unfolding filter_eq_iff
 proof safe
   fix P
   assume "eventually P (filtercomap f (F1 \<sqinter> F2))"
   then obtain Q R S where *:
     "eventually Q F1" "eventually R F2" "\<And>x. Q x \<Longrightarrow> R x \<Longrightarrow> S x" "\<And>x. S (f x) \<Longrightarrow> P x"
     unfolding eventually_filtercomap eventually_inf by blast
   from * have "eventually (\<lambda>x. Q (f x)) (filtercomap f F1)" 
               "eventually (\<lambda>x. R (f x)) (filtercomap f F2)"
     by (auto simp: eventually_filtercomap)
   with * show "eventually P (filtercomap f F1 \<sqinter> filtercomap f F2)"
     unfolding eventually_inf by blast
 next
   fix P
   assume "eventually P (inf (filtercomap f F1) (filtercomap f F2))"
   then obtain Q Q' R R' where *:
     "eventually Q F1" "eventually R F2" "\<And>x. Q (f x) \<Longrightarrow> Q' x" "\<And>x. R (f x) \<Longrightarrow> R' x" 
     "\<And>x. Q' x \<Longrightarrow> R' x \<Longrightarrow> P x"
     unfolding eventually_filtercomap eventually_inf by blast
   from * have "eventually (\<lambda>x. Q x \<and> R x) (F1 \<sqinter> F2)" by (auto simp: eventually_inf)
   with * show "eventually P (filtercomap f (F1 \<sqinter> F2))"
     by (auto simp: eventually_filtercomap)
 qed
 
 lemma filtercomap_sup: "filtercomap f (sup F1 F2) \<ge> sup (filtercomap f F1) (filtercomap f F2)"
   by (intro sup_least filtercomap_mono inf_sup_ord)
 
 lemma filtercomap_INF: "filtercomap f (\<Sqinter>b\<in>B. F b) = (\<Sqinter>b\<in>B. filtercomap f (F b))"
 proof -
   have *: "filtercomap f (\<Sqinter>b\<in>B. F b) = (\<Sqinter>b\<in>B. filtercomap f (F b))" if "finite B" for B
     using that by induction (simp_all add: filtercomap_inf)
   show ?thesis unfolding filter_eq_iff
   proof
     fix P
     have "eventually P (\<Sqinter>b\<in>B. filtercomap f (F b)) \<longleftrightarrow> 
             (\<exists>X. (X \<subseteq> B \<and> finite X) \<and> eventually P (\<Sqinter>b\<in>X. filtercomap f (F b)))"
       by (subst eventually_INF) blast
     also have "\<dots> \<longleftrightarrow> (\<exists>X. (X \<subseteq> B \<and> finite X) \<and> eventually P (filtercomap f (\<Sqinter>b\<in>X. F b)))"
       by (rule ex_cong) (simp add: *)
     also have "\<dots> \<longleftrightarrow> eventually P (filtercomap f (\<Sqinter>(F ` B)))"
       unfolding eventually_filtercomap by (subst eventually_INF) blast
     finally show "eventually P (filtercomap f (\<Sqinter>(F ` B))) = 
                     eventually P (\<Sqinter>b\<in>B. filtercomap f (F b))" ..
   qed
 qed
 
 lemma filtercomap_SUP:
   "filtercomap f (\<Squnion>b\<in>B. F b) \<ge> (\<Squnion>b\<in>B. filtercomap f (F b))"
   by (intro SUP_least filtercomap_mono SUP_upper)
 
 lemma filtermap_le_iff_le_filtercomap: "filtermap f F \<le> G \<longleftrightarrow> F \<le> filtercomap f G"
   unfolding le_filter_def eventually_filtermap eventually_filtercomap
   using eventually_mono by auto
 
 lemma filtercomap_neq_bot:
   assumes "\<And>P. eventually P F \<Longrightarrow> \<exists>x. P (f x)"
   shows   "filtercomap f F \<noteq> bot"
   using assms by (auto simp: trivial_limit_def eventually_filtercomap)
 
 lemma filtercomap_neq_bot_surj:
   assumes "F \<noteq> bot" and "surj f"
   shows   "filtercomap f F \<noteq> bot"
 proof (rule filtercomap_neq_bot)
   fix P assume *: "eventually P F"
   show "\<exists>x. P (f x)"
   proof (rule ccontr)
     assume **: "\<not>(\<exists>x. P (f x))"
     from * have "eventually (\<lambda>_. False) F"
     proof eventually_elim
       case (elim x)
       from \<open>surj f\<close> obtain y where "x = f y" by auto
       with elim and ** show False by auto
     qed
     with assms show False by (simp add: trivial_limit_def)
   qed
 qed
 
 lemma eventually_filtercomapI [intro]:
   assumes "eventually P F"
   shows   "eventually (\<lambda>x. P (f x)) (filtercomap f F)"
   using assms by (auto simp: eventually_filtercomap)
 
 lemma filtermap_filtercomap: "filtermap f (filtercomap f F) \<le> F"
   by (auto simp: le_filter_def eventually_filtermap eventually_filtercomap)
 
 lemma filtercomap_filtermap: "filtercomap f (filtermap f F) \<ge> F"
   unfolding le_filter_def eventually_filtermap eventually_filtercomap
   by (auto elim!: eventually_mono)
 
 
 subsubsection \<open>Standard filters\<close>
 
 definition principal :: "'a set \<Rightarrow> 'a filter" where
   "principal S = Abs_filter (\<lambda>P. \<forall>x\<in>S. P x)"
 
 lemma eventually_principal: "eventually P (principal S) \<longleftrightarrow> (\<forall>x\<in>S. P x)"
   unfolding principal_def
   by (rule eventually_Abs_filter, rule is_filter.intro) auto
 
 lemma eventually_inf_principal: "eventually P (inf F (principal s)) \<longleftrightarrow> eventually (\<lambda>x. x \<in> s \<longrightarrow> P x) F"
   unfolding eventually_inf eventually_principal by (auto elim: eventually_mono)
 
 lemma principal_UNIV[simp]: "principal UNIV = top"
   by (auto simp: filter_eq_iff eventually_principal)
 
 lemma principal_empty[simp]: "principal {} = bot"
   by (auto simp: filter_eq_iff eventually_principal)
 
 lemma principal_eq_bot_iff: "principal X = bot \<longleftrightarrow> X = {}"
   by (auto simp add: filter_eq_iff eventually_principal)
 
 lemma principal_le_iff[iff]: "principal A \<le> principal B \<longleftrightarrow> A \<subseteq> B"
   by (auto simp: le_filter_def eventually_principal)
 
 lemma le_principal: "F \<le> principal A \<longleftrightarrow> eventually (\<lambda>x. x \<in> A) F"
   unfolding le_filter_def eventually_principal
   by (force elim: eventually_mono)
 
 lemma principal_inject[iff]: "principal A = principal B \<longleftrightarrow> A = B"
   unfolding eq_iff by simp
 
 lemma sup_principal[simp]: "sup (principal A) (principal B) = principal (A \<union> B)"
   unfolding filter_eq_iff eventually_sup eventually_principal by auto
 
 lemma inf_principal[simp]: "inf (principal A) (principal B) = principal (A \<inter> B)"
   unfolding filter_eq_iff eventually_inf eventually_principal
   by (auto intro: exI[of _ "\<lambda>x. x \<in> A"] exI[of _ "\<lambda>x. x \<in> B"])
 
 lemma SUP_principal[simp]: "(\<Squnion>i\<in>I. principal (A i)) = principal (\<Union>i\<in>I. A i)"
   unfolding filter_eq_iff eventually_Sup by (auto simp: eventually_principal)
 
 lemma INF_principal_finite: "finite X \<Longrightarrow> (\<Sqinter>x\<in>X. principal (f x)) = principal (\<Inter>x\<in>X. f x)"
   by (induct X rule: finite_induct) auto
 
 lemma filtermap_principal[simp]: "filtermap f (principal A) = principal (f ` A)"
   unfolding filter_eq_iff eventually_filtermap eventually_principal by simp
     
 lemma filtercomap_principal[simp]: "filtercomap f (principal A) = principal (f -` A)"
   unfolding filter_eq_iff eventually_filtercomap eventually_principal by fast
 
 subsubsection \<open>Order filters\<close>
 
 definition at_top :: "('a::order) filter"
   where "at_top = (\<Sqinter>k. principal {k ..})"
 
 lemma at_top_sub: "at_top = (\<Sqinter>k\<in>{c::'a::linorder..}. principal {k ..})"
   by (auto intro!: INF_eq max.cobounded1 max.cobounded2 simp: at_top_def)
 
 lemma eventually_at_top_linorder: "eventually P at_top \<longleftrightarrow> (\<exists>N::'a::linorder. \<forall>n\<ge>N. P n)"
   unfolding at_top_def
   by (subst eventually_INF_base) (auto simp: eventually_principal intro: max.cobounded1 max.cobounded2)
 
 lemma eventually_filtercomap_at_top_linorder: 
   "eventually P (filtercomap f at_top) \<longleftrightarrow> (\<exists>N::'a::linorder. \<forall>x. f x \<ge> N \<longrightarrow> P x)"
   by (auto simp: eventually_filtercomap eventually_at_top_linorder)
 
 lemma eventually_at_top_linorderI:
   fixes c::"'a::linorder"
   assumes "\<And>x. c \<le> x \<Longrightarrow> P x"
   shows "eventually P at_top"
   using assms by (auto simp: eventually_at_top_linorder)
 
 lemma eventually_ge_at_top [simp]:
   "eventually (\<lambda>x. (c::_::linorder) \<le> x) at_top"
   unfolding eventually_at_top_linorder by auto
 
 lemma eventually_at_top_dense: "eventually P at_top \<longleftrightarrow> (\<exists>N::'a::{no_top, linorder}. \<forall>n>N. P n)"
 proof -
   have "eventually P (\<Sqinter>k. principal {k <..}) \<longleftrightarrow> (\<exists>N::'a. \<forall>n>N. P n)"
     by (subst eventually_INF_base) (auto simp: eventually_principal intro: max.cobounded1 max.cobounded2)
   also have "(\<Sqinter>k. principal {k::'a <..}) = at_top"
     unfolding at_top_def
     by (intro INF_eq) (auto intro: less_imp_le simp: Ici_subset_Ioi_iff gt_ex)
   finally show ?thesis .
 qed
   
 lemma eventually_filtercomap_at_top_dense: 
   "eventually P (filtercomap f at_top) \<longleftrightarrow> (\<exists>N::'a::{no_top, linorder}. \<forall>x. f x > N \<longrightarrow> P x)"
   by (auto simp: eventually_filtercomap eventually_at_top_dense)
 
 lemma eventually_at_top_not_equal [simp]: "eventually (\<lambda>x::'a::{no_top, linorder}. x \<noteq> c) at_top"
   unfolding eventually_at_top_dense by auto
 
 lemma eventually_gt_at_top [simp]: "eventually (\<lambda>x. (c::_::{no_top, linorder}) < x) at_top"
   unfolding eventually_at_top_dense by auto
 
 lemma eventually_all_ge_at_top:
   assumes "eventually P (at_top :: ('a :: linorder) filter)"
   shows   "eventually (\<lambda>x. \<forall>y\<ge>x. P y) at_top"
 proof -
   from assms obtain x where "\<And>y. y \<ge> x \<Longrightarrow> P y" by (auto simp: eventually_at_top_linorder)
   hence "\<forall>z\<ge>y. P z" if "y \<ge> x" for y using that by simp
   thus ?thesis by (auto simp: eventually_at_top_linorder)
 qed
 
 definition at_bot :: "('a::order) filter"
   where "at_bot = (\<Sqinter>k. principal {.. k})"
 
 lemma at_bot_sub: "at_bot = (\<Sqinter>k\<in>{.. c::'a::linorder}. principal {.. k})"
   by (auto intro!: INF_eq min.cobounded1 min.cobounded2 simp: at_bot_def)
 
 lemma eventually_at_bot_linorder:
   fixes P :: "'a::linorder \<Rightarrow> bool" shows "eventually P at_bot \<longleftrightarrow> (\<exists>N. \<forall>n\<le>N. P n)"
   unfolding at_bot_def
   by (subst eventually_INF_base) (auto simp: eventually_principal intro: min.cobounded1 min.cobounded2)
 
 lemma eventually_filtercomap_at_bot_linorder: 
   "eventually P (filtercomap f at_bot) \<longleftrightarrow> (\<exists>N::'a::linorder. \<forall>x. f x \<le> N \<longrightarrow> P x)"
   by (auto simp: eventually_filtercomap eventually_at_bot_linorder)
 
 lemma eventually_le_at_bot [simp]:
   "eventually (\<lambda>x. x \<le> (c::_::linorder)) at_bot"
   unfolding eventually_at_bot_linorder by auto
 
 lemma eventually_at_bot_dense: "eventually P at_bot \<longleftrightarrow> (\<exists>N::'a::{no_bot, linorder}. \<forall>n<N. P n)"
 proof -
   have "eventually P (\<Sqinter>k. principal {..< k}) \<longleftrightarrow> (\<exists>N::'a. \<forall>n<N. P n)"
     by (subst eventually_INF_base) (auto simp: eventually_principal intro: min.cobounded1 min.cobounded2)
   also have "(\<Sqinter>k. principal {..< k::'a}) = at_bot"
     unfolding at_bot_def
     by (intro INF_eq) (auto intro: less_imp_le simp: Iic_subset_Iio_iff lt_ex)
   finally show ?thesis .
 qed
 
 lemma eventually_filtercomap_at_bot_dense: 
   "eventually P (filtercomap f at_bot) \<longleftrightarrow> (\<exists>N::'a::{no_bot, linorder}. \<forall>x. f x < N \<longrightarrow> P x)"
   by (auto simp: eventually_filtercomap eventually_at_bot_dense)
 
 lemma eventually_at_bot_not_equal [simp]: "eventually (\<lambda>x::'a::{no_bot, linorder}. x \<noteq> c) at_bot"
   unfolding eventually_at_bot_dense by auto
 
 lemma eventually_gt_at_bot [simp]:
   "eventually (\<lambda>x. x < (c::_::unbounded_dense_linorder)) at_bot"
   unfolding eventually_at_bot_dense by auto
 
 lemma trivial_limit_at_bot_linorder [simp]: "\<not> trivial_limit (at_bot ::('a::linorder) filter)"
   unfolding trivial_limit_def
   by (metis eventually_at_bot_linorder order_refl)
 
 lemma trivial_limit_at_top_linorder [simp]: "\<not> trivial_limit (at_top ::('a::linorder) filter)"
   unfolding trivial_limit_def
   by (metis eventually_at_top_linorder order_refl)
 
 subsection \<open>Sequentially\<close>
 
 abbreviation sequentially :: "nat filter"
   where "sequentially \<equiv> at_top"
 
 lemma eventually_sequentially:
   "eventually P sequentially \<longleftrightarrow> (\<exists>N. \<forall>n\<ge>N. P n)"
   by (rule eventually_at_top_linorder)
 
 lemma sequentially_bot [simp, intro]: "sequentially \<noteq> bot"
   unfolding filter_eq_iff eventually_sequentially by auto
 
 lemmas trivial_limit_sequentially = sequentially_bot
 
 lemma eventually_False_sequentially [simp]:
   "\<not> eventually (\<lambda>n. False) sequentially"
   by (simp add: eventually_False)
 
 lemma le_sequentially:
   "F \<le> sequentially \<longleftrightarrow> (\<forall>N. eventually (\<lambda>n. N \<le> n) F)"
   by (simp add: at_top_def le_INF_iff le_principal)
 
 lemma eventually_sequentiallyI [intro?]:
   assumes "\<And>x. c \<le> x \<Longrightarrow> P x"
   shows "eventually P sequentially"
 using assms by (auto simp: eventually_sequentially)
 
 lemma eventually_sequentially_Suc [simp]: "eventually (\<lambda>i. P (Suc i)) sequentially \<longleftrightarrow> eventually P sequentially"
   unfolding eventually_sequentially by (metis Suc_le_D Suc_le_mono le_Suc_eq)
 
 lemma eventually_sequentially_seg [simp]: "eventually (\<lambda>n. P (n + k)) sequentially \<longleftrightarrow> eventually P sequentially"
   using eventually_sequentially_Suc[of "\<lambda>n. P (n + k)" for k] by (induction k) auto
 
 lemma filtermap_sequentually_ne_bot: "filtermap f sequentially \<noteq> bot"
   by (simp add: filtermap_bot_iff)
 
 subsection \<open>Increasing finite subsets\<close>
 
 definition finite_subsets_at_top where
   "finite_subsets_at_top A = (\<Sqinter> X\<in>{X. finite X \<and> X \<subseteq> A}. principal {Y. finite Y \<and> X \<subseteq> Y \<and> Y \<subseteq> A})"
 
 lemma eventually_finite_subsets_at_top:
   "eventually P (finite_subsets_at_top A) \<longleftrightarrow>
      (\<exists>X. finite X \<and> X \<subseteq> A \<and> (\<forall>Y. finite Y \<and> X \<subseteq> Y \<and> Y \<subseteq> A \<longrightarrow> P Y))"
   unfolding finite_subsets_at_top_def
 proof (subst eventually_INF_base, goal_cases)
   show "{X. finite X \<and> X \<subseteq> A} \<noteq> {}" by auto
 next
   case (2 B C)
   thus ?case by (intro bexI[of _ "B \<union> C"]) auto
 qed (simp_all add: eventually_principal)
 
 lemma eventually_finite_subsets_at_top_weakI [intro]:
   assumes "\<And>X. finite X \<Longrightarrow> X \<subseteq> A \<Longrightarrow> P X"
   shows   "eventually P (finite_subsets_at_top A)"
 proof -
   have "eventually (\<lambda>X. finite X \<and> X \<subseteq> A) (finite_subsets_at_top A)"
     by (auto simp: eventually_finite_subsets_at_top)
   thus ?thesis by eventually_elim (use assms in auto)
 qed
 
 lemma finite_subsets_at_top_neq_bot [simp]: "finite_subsets_at_top A \<noteq> bot"
 proof -
   have "\<not>eventually (\<lambda>x. False) (finite_subsets_at_top A)"
     by (auto simp: eventually_finite_subsets_at_top)
   thus ?thesis by auto
 qed
 
 lemma filtermap_image_finite_subsets_at_top:
   assumes "inj_on f A"
   shows   "filtermap ((`) f) (finite_subsets_at_top A) = finite_subsets_at_top (f ` A)"
   unfolding filter_eq_iff eventually_filtermap
 proof (safe, goal_cases)
   case (1 P)
   then obtain X where X: "finite X" "X \<subseteq> A" "\<And>Y. finite Y \<Longrightarrow> X \<subseteq> Y \<Longrightarrow> Y \<subseteq> A \<Longrightarrow> P (f ` Y)"
     unfolding eventually_finite_subsets_at_top by force
   show ?case unfolding eventually_finite_subsets_at_top eventually_filtermap
   proof (rule exI[of _ "f ` X"], intro conjI allI impI, goal_cases)
     case (3 Y)
     with assms and X(1,2) have "P (f ` (f -` Y \<inter> A))" using X(1,2)
       by (intro X(3) finite_vimage_IntI) auto
     also have "f ` (f -` Y \<inter> A) = Y" using assms 3 by blast
     finally show ?case .
   qed (insert assms X(1,2), auto intro!: finite_vimage_IntI)
 next
   case (2 P)
   then obtain X where X: "finite X" "X \<subseteq> f ` A" "\<And>Y. finite Y \<Longrightarrow> X \<subseteq> Y \<Longrightarrow> Y \<subseteq> f ` A \<Longrightarrow> P Y"
     unfolding eventually_finite_subsets_at_top by force
   show ?case unfolding eventually_finite_subsets_at_top eventually_filtermap
   proof (rule exI[of _ "f -` X \<inter> A"], intro conjI allI impI, goal_cases)
     case (3 Y)
     with X(1,2) and assms show ?case by (intro X(3)) force+
   qed (insert assms X(1), auto intro!: finite_vimage_IntI)
 qed
 
 lemma eventually_finite_subsets_at_top_finite:
   assumes "finite A"
   shows   "eventually P (finite_subsets_at_top A) \<longleftrightarrow> P A"
   unfolding eventually_finite_subsets_at_top using assms by force
 
 lemma finite_subsets_at_top_finite: "finite A \<Longrightarrow> finite_subsets_at_top A = principal {A}"
   by (auto simp: filter_eq_iff eventually_finite_subsets_at_top_finite eventually_principal)
 
 
 subsection \<open>The cofinite filter\<close>
 
 definition "cofinite = Abs_filter (\<lambda>P. finite {x. \<not> P x})"
 
 abbreviation Inf_many :: "('a \<Rightarrow> bool) \<Rightarrow> bool"  (binder "\<exists>\<^sub>\<infinity>" 10)
   where "Inf_many P \<equiv> frequently P cofinite"
 
 abbreviation Alm_all :: "('a \<Rightarrow> bool) \<Rightarrow> bool"  (binder "\<forall>\<^sub>\<infinity>" 10)
   where "Alm_all P \<equiv> eventually P cofinite"
 
 notation (ASCII)
   Inf_many  (binder "INFM " 10) and
   Alm_all  (binder "MOST " 10)
 
 lemma eventually_cofinite: "eventually P cofinite \<longleftrightarrow> finite {x. \<not> P x}"
   unfolding cofinite_def
 proof (rule eventually_Abs_filter, rule is_filter.intro)
   fix P Q :: "'a \<Rightarrow> bool" assume "finite {x. \<not> P x}" "finite {x. \<not> Q x}"
   from finite_UnI[OF this] show "finite {x. \<not> (P x \<and> Q x)}"
     by (rule rev_finite_subset) auto
 next
   fix P Q :: "'a \<Rightarrow> bool" assume P: "finite {x. \<not> P x}" and *: "\<forall>x. P x \<longrightarrow> Q x"
   from * show "finite {x. \<not> Q x}"
     by (intro finite_subset[OF _ P]) auto
 qed simp
 
 lemma frequently_cofinite: "frequently P cofinite \<longleftrightarrow> \<not> finite {x. P x}"
   by (simp add: frequently_def eventually_cofinite)
 
 lemma cofinite_bot[simp]: "cofinite = (bot::'a filter) \<longleftrightarrow> finite (UNIV :: 'a set)"
   unfolding trivial_limit_def eventually_cofinite by simp
 
 lemma cofinite_eq_sequentially: "cofinite = sequentially"
   unfolding filter_eq_iff eventually_sequentially eventually_cofinite
 proof safe
   fix P :: "nat \<Rightarrow> bool" assume [simp]: "finite {x. \<not> P x}"
   show "\<exists>N. \<forall>n\<ge>N. P n"
   proof cases
     assume "{x. \<not> P x} \<noteq> {}" then show ?thesis
       by (intro exI[of _ "Suc (Max {x. \<not> P x})"]) (auto simp: Suc_le_eq)
   qed auto
 next
   fix P :: "nat \<Rightarrow> bool" and N :: nat assume "\<forall>n\<ge>N. P n"
   then have "{x. \<not> P x} \<subseteq> {..< N}"
     by (auto simp: not_le)
   then show "finite {x. \<not> P x}"
     by (blast intro: finite_subset)
 qed
 
 subsubsection \<open>Product of filters\<close>
 
 definition prod_filter :: "'a filter \<Rightarrow> 'b filter \<Rightarrow> ('a \<times> 'b) filter" (infixr "\<times>\<^sub>F" 80) where
   "prod_filter F G =
     (\<Sqinter>(P, Q)\<in>{(P, Q). eventually P F \<and> eventually Q G}. principal {(x, y). P x \<and> Q y})"
 
 lemma eventually_prod_filter: "eventually P (F \<times>\<^sub>F G) \<longleftrightarrow>
   (\<exists>Pf Pg. eventually Pf F \<and> eventually Pg G \<and> (\<forall>x y. Pf x \<longrightarrow> Pg y \<longrightarrow> P (x, y)))"
   unfolding prod_filter_def
 proof (subst eventually_INF_base, goal_cases)
   case 2
   moreover have "eventually Pf F \<Longrightarrow> eventually Qf F \<Longrightarrow> eventually Pg G \<Longrightarrow> eventually Qg G \<Longrightarrow>
     \<exists>P Q. eventually P F \<and> eventually Q G \<and>
       Collect P \<times> Collect Q \<subseteq> Collect Pf \<times> Collect Pg \<inter> Collect Qf \<times> Collect Qg" for Pf Pg Qf Qg
     by (intro conjI exI[of _ "inf Pf Qf"] exI[of _ "inf Pg Qg"])
        (auto simp: inf_fun_def eventually_conj)
   ultimately show ?case
     by auto
 qed (auto simp: eventually_principal intro: eventually_True)
 
 lemma eventually_prod1:
   assumes "B \<noteq> bot"
   shows "(\<forall>\<^sub>F (x, y) in A \<times>\<^sub>F B. P x) \<longleftrightarrow> (\<forall>\<^sub>F x in A. P x)"
   unfolding eventually_prod_filter
 proof safe
   fix R Q
   assume *: "\<forall>\<^sub>F x in A. R x" "\<forall>\<^sub>F x in B. Q x" "\<forall>x y. R x \<longrightarrow> Q y \<longrightarrow> P x"
   with \<open>B \<noteq> bot\<close> obtain y where "Q y" by (auto dest: eventually_happens)
   with * show "eventually P A"
     by (force elim: eventually_mono)
 next
   assume "eventually P A"
   then show "\<exists>Pf Pg. eventually Pf A \<and> eventually Pg B \<and> (\<forall>x y. Pf x \<longrightarrow> Pg y \<longrightarrow> P x)"
     by (intro exI[of _ P] exI[of _ "\<lambda>x. True"]) auto
 qed
 
 lemma eventually_prod2:
   assumes "A \<noteq> bot"
   shows "(\<forall>\<^sub>F (x, y) in A \<times>\<^sub>F B. P y) \<longleftrightarrow> (\<forall>\<^sub>F y in B. P y)"
   unfolding eventually_prod_filter
 proof safe
   fix R Q
   assume *: "\<forall>\<^sub>F x in A. R x" "\<forall>\<^sub>F x in B. Q x" "\<forall>x y. R x \<longrightarrow> Q y \<longrightarrow> P y"
   with \<open>A \<noteq> bot\<close> obtain x where "R x" by (auto dest: eventually_happens)
   with * show "eventually P B"
     by (force elim: eventually_mono)
 next
   assume "eventually P B"
   then show "\<exists>Pf Pg. eventually Pf A \<and> eventually Pg B \<and> (\<forall>x y. Pf x \<longrightarrow> Pg y \<longrightarrow> P y)"
     by (intro exI[of _ P] exI[of _ "\<lambda>x. True"]) auto
 qed
 
 lemma INF_filter_bot_base:
   fixes F :: "'a \<Rightarrow> 'b filter"
   assumes *: "\<And>i j. i \<in> I \<Longrightarrow> j \<in> I \<Longrightarrow> \<exists>k\<in>I. F k \<le> F i \<sqinter> F j"
   shows "(\<Sqinter>i\<in>I. F i) = bot \<longleftrightarrow> (\<exists>i\<in>I. F i = bot)"
 proof (cases "\<exists>i\<in>I. F i = bot")
   case True
   then have "(\<Sqinter>i\<in>I. F i) \<le> bot"
     by (auto intro: INF_lower2)
   with True show ?thesis
     by (auto simp: bot_unique)
 next
   case False
   moreover have "(\<Sqinter>i\<in>I. F i) \<noteq> bot"
   proof (cases "I = {}")
     case True
     then show ?thesis
       by (auto simp add: filter_eq_iff)
   next
     case False': False
     show ?thesis
     proof (rule INF_filter_not_bot)
       fix J
       assume "finite J" "J \<subseteq> I"
       then have "\<exists>k\<in>I. F k \<le> (\<Sqinter>i\<in>J. F i)"
       proof (induct J)
         case empty
         then show ?case
           using \<open>I \<noteq> {}\<close> by auto
       next
         case (insert i J)
         then obtain k where "k \<in> I" "F k \<le> (\<Sqinter>i\<in>J. F i)" by auto
         with insert *[of i k] show ?case
           by auto
       qed
       with False show "(\<Sqinter>i\<in>J. F i) \<noteq> \<bottom>"
         by (auto simp: bot_unique)
     qed
   qed
   ultimately show ?thesis
     by auto
 qed
 
 lemma Collect_empty_eq_bot: "Collect P = {} \<longleftrightarrow> P = \<bottom>"
   by auto
 
 lemma prod_filter_eq_bot: "A \<times>\<^sub>F B = bot \<longleftrightarrow> A = bot \<or> B = bot"
   unfolding trivial_limit_def
 proof
   assume "\<forall>\<^sub>F x in A \<times>\<^sub>F B. False"
   then obtain Pf Pg
     where Pf: "eventually (\<lambda>x. Pf x) A" and Pg: "eventually (\<lambda>y. Pg y) B"
     and *: "\<forall>x y. Pf x \<longrightarrow> Pg y \<longrightarrow> False"
     unfolding eventually_prod_filter by fast
   from * have "(\<forall>x. \<not> Pf x) \<or> (\<forall>y. \<not> Pg y)" by fast
   with Pf Pg show "(\<forall>\<^sub>F x in A. False) \<or> (\<forall>\<^sub>F x in B. False)" by auto
 next
   assume "(\<forall>\<^sub>F x in A. False) \<or> (\<forall>\<^sub>F x in B. False)"
   then show "\<forall>\<^sub>F x in A \<times>\<^sub>F B. False"
     unfolding eventually_prod_filter by (force intro: eventually_True)
 qed
 
 lemma prod_filter_mono: "F \<le> F' \<Longrightarrow> G \<le> G' \<Longrightarrow> F \<times>\<^sub>F G \<le> F' \<times>\<^sub>F G'"
   by (auto simp: le_filter_def eventually_prod_filter)
 
 lemma prod_filter_mono_iff:
   assumes nAB: "A \<noteq> bot" "B \<noteq> bot"
   shows "A \<times>\<^sub>F B \<le> C \<times>\<^sub>F D \<longleftrightarrow> A \<le> C \<and> B \<le> D"
 proof safe
   assume *: "A \<times>\<^sub>F B \<le> C \<times>\<^sub>F D"
   with assms have "A \<times>\<^sub>F B \<noteq> bot"
     by (auto simp: bot_unique prod_filter_eq_bot)
   with * have "C \<times>\<^sub>F D \<noteq> bot"
     by (auto simp: bot_unique)
   then have nCD: "C \<noteq> bot" "D \<noteq> bot"
     by (auto simp: prod_filter_eq_bot)
 
   show "A \<le> C"
   proof (rule filter_leI)
     fix P assume "eventually P C" with *[THEN filter_leD, of "\<lambda>(x, y). P x"] show "eventually P A"
       using nAB nCD by (simp add: eventually_prod1 eventually_prod2)
   qed
 
   show "B \<le> D"
   proof (rule filter_leI)
     fix P assume "eventually P D" with *[THEN filter_leD, of "\<lambda>(x, y). P y"] show "eventually P B"
       using nAB nCD by (simp add: eventually_prod1 eventually_prod2)
   qed
 qed (intro prod_filter_mono)
 
 lemma eventually_prod_same: "eventually P (F \<times>\<^sub>F F) \<longleftrightarrow>
     (\<exists>Q. eventually Q F \<and> (\<forall>x y. Q x \<longrightarrow> Q y \<longrightarrow> P (x, y)))"
   unfolding eventually_prod_filter by (blast intro!: eventually_conj)
 
 lemma eventually_prod_sequentially:
   "eventually P (sequentially \<times>\<^sub>F sequentially) \<longleftrightarrow> (\<exists>N. \<forall>m \<ge> N. \<forall>n \<ge> N. P (n, m))"
   unfolding eventually_prod_same eventually_sequentially by auto
 
 lemma principal_prod_principal: "principal A \<times>\<^sub>F principal B = principal (A \<times> B)"
   unfolding filter_eq_iff eventually_prod_filter eventually_principal
   by (fast intro: exI[of _ "\<lambda>x. x \<in> A"] exI[of _ "\<lambda>x. x \<in> B"])
 
 lemma le_prod_filterI:
   "filtermap fst F \<le> A \<Longrightarrow> filtermap snd F \<le> B \<Longrightarrow> F \<le> A \<times>\<^sub>F B"
   unfolding le_filter_def eventually_filtermap eventually_prod_filter
   by (force elim: eventually_elim2)
 
 lemma filtermap_fst_prod_filter: "filtermap fst (A \<times>\<^sub>F B) \<le> A"
   unfolding le_filter_def eventually_filtermap eventually_prod_filter
   by (force intro: eventually_True)
 
 lemma filtermap_snd_prod_filter: "filtermap snd (A \<times>\<^sub>F B) \<le> B"
   unfolding le_filter_def eventually_filtermap eventually_prod_filter
   by (force intro: eventually_True)
 
 lemma prod_filter_INF:
   assumes "I \<noteq> {}" and "J \<noteq> {}"
   shows "(\<Sqinter>i\<in>I. A i) \<times>\<^sub>F (\<Sqinter>j\<in>J. B j) = (\<Sqinter>i\<in>I. \<Sqinter>j\<in>J. A i \<times>\<^sub>F B j)"
 proof (rule antisym)
   from \<open>I \<noteq> {}\<close> obtain i where "i \<in> I" by auto
   from \<open>J \<noteq> {}\<close> obtain j where "j \<in> J" by auto
 
   show "(\<Sqinter>i\<in>I. \<Sqinter>j\<in>J. A i \<times>\<^sub>F B j) \<le> (\<Sqinter>i\<in>I. A i) \<times>\<^sub>F (\<Sqinter>j\<in>J. B j)"
     by (fast intro: le_prod_filterI INF_greatest INF_lower2
       order_trans[OF filtermap_INF] \<open>i \<in> I\<close> \<open>j \<in> J\<close>
       filtermap_fst_prod_filter filtermap_snd_prod_filter)
   show "(\<Sqinter>i\<in>I. A i) \<times>\<^sub>F (\<Sqinter>j\<in>J. B j) \<le> (\<Sqinter>i\<in>I. \<Sqinter>j\<in>J. A i \<times>\<^sub>F B j)"
     by (intro INF_greatest prod_filter_mono INF_lower)
 qed
 
 lemma filtermap_Pair: "filtermap (\<lambda>x. (f x, g x)) F \<le> filtermap f F \<times>\<^sub>F filtermap g F"
   by (rule le_prod_filterI, simp_all add: filtermap_filtermap)
 
 lemma eventually_prodI: "eventually P F \<Longrightarrow> eventually Q G \<Longrightarrow> eventually (\<lambda>x. P (fst x) \<and> Q (snd x)) (F \<times>\<^sub>F G)"
   unfolding eventually_prod_filter by auto
 
 lemma prod_filter_INF1: "I \<noteq> {} \<Longrightarrow> (\<Sqinter>i\<in>I. A i) \<times>\<^sub>F B = (\<Sqinter>i\<in>I. A i \<times>\<^sub>F B)"
   using prod_filter_INF[of I "{B}" A "\<lambda>x. x"] by simp
 
 lemma prod_filter_INF2: "J \<noteq> {} \<Longrightarrow> A \<times>\<^sub>F (\<Sqinter>i\<in>J. B i) = (\<Sqinter>i\<in>J. A \<times>\<^sub>F B i)"
   using prod_filter_INF[of "{A}" J "\<lambda>x. x" B] by simp
 
 lemma prod_filtermap1: "prod_filter (filtermap f F) G = filtermap (apfst f) (prod_filter F G)"
   unfolding filter_eq_iff eventually_filtermap eventually_prod_filter
   apply safe
   subgoal by auto
   subgoal for P Q R by(rule exI[where x="\<lambda>y. \<exists>x. y = f x \<and> Q x"])(auto intro: eventually_mono)
   done
 
 lemma prod_filtermap2: "prod_filter F (filtermap g G) = filtermap (apsnd g) (prod_filter F G)"
   unfolding filter_eq_iff eventually_filtermap eventually_prod_filter
   apply safe
   subgoal by auto
   subgoal for P Q R  by(auto intro: exI[where x="\<lambda>y. \<exists>x. y = g x \<and> R x"] eventually_mono)
   done
 
 lemma prod_filter_assoc:
   "prod_filter (prod_filter F G) H = filtermap (\<lambda>(x, y, z). ((x, y), z)) (prod_filter F (prod_filter G H))"
   apply(clarsimp simp add: filter_eq_iff eventually_filtermap eventually_prod_filter; safe)
   subgoal for P Q R S T by(auto 4 4 intro: exI[where x="\<lambda>(a, b). T a \<and> S b"])
   subgoal for P Q R S T by(auto 4 3 intro: exI[where x="\<lambda>(a, b). Q a \<and> S b"])
   done
 
 lemma prod_filter_principal_singleton: "prod_filter (principal {x}) F = filtermap (Pair x) F"
   by(fastforce simp add: filter_eq_iff eventually_prod_filter eventually_principal eventually_filtermap elim: eventually_mono intro: exI[where x="\<lambda>a. a = x"])
 
 lemma prod_filter_principal_singleton2: "prod_filter F (principal {x}) = filtermap (\<lambda>a. (a, x)) F"
   by(fastforce simp add: filter_eq_iff eventually_prod_filter eventually_principal eventually_filtermap elim: eventually_mono intro: exI[where x="\<lambda>a. a = x"])
 
 lemma prod_filter_commute: "prod_filter F G = filtermap prod.swap (prod_filter G F)"
   by(auto simp add: filter_eq_iff eventually_prod_filter eventually_filtermap)
 
 subsection \<open>Limits\<close>
 
 definition filterlim :: "('a \<Rightarrow> 'b) \<Rightarrow> 'b filter \<Rightarrow> 'a filter \<Rightarrow> bool" where
   "filterlim f F2 F1 \<longleftrightarrow> filtermap f F1 \<le> F2"
 
 syntax
   "_LIM" :: "pttrns \<Rightarrow> 'a \<Rightarrow> 'b \<Rightarrow> 'a \<Rightarrow> bool" ("(3LIM (_)/ (_)./ (_) :> (_))" [1000, 10, 0, 10] 10)
 
 translations
   "LIM x F1. f :> F2" == "CONST filterlim (\<lambda>x. f) F2 F1"
 
 lemma filterlim_top [simp]: "filterlim f top F"
   by (simp add: filterlim_def)
 
 lemma filterlim_iff:
   "(LIM x F1. f x :> F2) \<longleftrightarrow> (\<forall>P. eventually P F2 \<longrightarrow> eventually (\<lambda>x. P (f x)) F1)"
   unfolding filterlim_def le_filter_def eventually_filtermap ..
 
 lemma filterlim_compose:
   "filterlim g F3 F2 \<Longrightarrow> filterlim f F2 F1 \<Longrightarrow> filterlim (\<lambda>x. g (f x)) F3 F1"
   unfolding filterlim_def filtermap_filtermap[symmetric] by (metis filtermap_mono order_trans)
 
 lemma filterlim_mono:
   "filterlim f F2 F1 \<Longrightarrow> F2 \<le> F2' \<Longrightarrow> F1' \<le> F1 \<Longrightarrow> filterlim f F2' F1'"
   unfolding filterlim_def by (metis filtermap_mono order_trans)
 
 lemma filterlim_ident: "LIM x F. x :> F"
   by (simp add: filterlim_def filtermap_ident)
 
 lemma filterlim_cong:
   "F1 = F1' \<Longrightarrow> F2 = F2' \<Longrightarrow> eventually (\<lambda>x. f x = g x) F2 \<Longrightarrow> filterlim f F1 F2 = filterlim g F1' F2'"
   by (auto simp: filterlim_def le_filter_def eventually_filtermap elim: eventually_elim2)
 
 lemma filterlim_mono_eventually:
   assumes "filterlim f F G" and ord: "F \<le> F'" "G' \<le> G"
   assumes eq: "eventually (\<lambda>x. f x = f' x) G'"
   shows "filterlim f' F' G'"
 proof -
   have "filterlim f F' G'"
     by (simp add: filterlim_mono[OF _ ord] assms)
   then show ?thesis
     by (rule filterlim_cong[OF refl refl eq, THEN iffD1])
 qed
 
 lemma filtermap_mono_strong: "inj f \<Longrightarrow> filtermap f F \<le> filtermap f G \<longleftrightarrow> F \<le> G"
   apply (safe intro!: filtermap_mono)
   apply (auto simp: le_filter_def eventually_filtermap)
   apply (erule_tac x="\<lambda>x. P (inv f x)" in allE)
   apply auto
   done
 
 lemma eventually_compose_filterlim:
   assumes "eventually P F" "filterlim f F G"
   shows "eventually (\<lambda>x. P (f x)) G"
   using assms by (simp add: filterlim_iff)
 
 lemma filtermap_eq_strong: "inj f \<Longrightarrow> filtermap f F = filtermap f G \<longleftrightarrow> F = G"
   by (simp add: filtermap_mono_strong eq_iff)
 
 lemma filtermap_fun_inverse:
   assumes g: "filterlim g F G"
   assumes f: "filterlim f G F"
   assumes ev: "eventually (\<lambda>x. f (g x) = x) G"
   shows "filtermap f F = G"
 proof (rule antisym)
   show "filtermap f F \<le> G"
     using f unfolding filterlim_def .
   have "G = filtermap f (filtermap g G)"
     using ev by (auto elim: eventually_elim2 simp: filter_eq_iff eventually_filtermap)
   also have "\<dots> \<le> filtermap f F"
     using g by (intro filtermap_mono) (simp add: filterlim_def)
   finally show "G \<le> filtermap f F" .
 qed
 
 lemma filterlim_principal:
   "(LIM x F. f x :> principal S) \<longleftrightarrow> (eventually (\<lambda>x. f x \<in> S) F)"
   unfolding filterlim_def eventually_filtermap le_principal ..
 
 lemma filterlim_filtercomap [intro]: "filterlim f F (filtercomap f F)"
   unfolding filterlim_def by (rule filtermap_filtercomap)
 
 lemma filterlim_inf:
   "(LIM x F1. f x :> inf F2 F3) \<longleftrightarrow> ((LIM x F1. f x :> F2) \<and> (LIM x F1. f x :> F3))"
   unfolding filterlim_def by simp
 
 lemma filterlim_INF:
   "(LIM x F. f x :> (\<Sqinter>b\<in>B. G b)) \<longleftrightarrow> (\<forall>b\<in>B. LIM x F. f x :> G b)"
   unfolding filterlim_def le_INF_iff ..
 
 lemma filterlim_INF_INF:
   "(\<And>m. m \<in> J \<Longrightarrow> \<exists>i\<in>I. filtermap f (F i) \<le> G m) \<Longrightarrow> LIM x (\<Sqinter>i\<in>I. F i). f x :> (\<Sqinter>j\<in>J. G j)"
   unfolding filterlim_def by (rule order_trans[OF filtermap_INF INF_mono])
 
 lemma filterlim_INF': "x \<in> A \<Longrightarrow> filterlim f F (G x) \<Longrightarrow> filterlim f F (\<Sqinter> x\<in>A. G x)"
   unfolding filterlim_def by (rule order.trans[OF filtermap_mono[OF INF_lower]])
 
 lemma filterlim_filtercomap_iff: "filterlim f (filtercomap g G) F \<longleftrightarrow> filterlim (g \<circ> f) G F"
   by (simp add: filterlim_def filtermap_le_iff_le_filtercomap filtercomap_filtercomap o_def)
 
 lemma filterlim_iff_le_filtercomap: "filterlim f F G \<longleftrightarrow> G \<le> filtercomap f F"
   by (simp add: filterlim_def filtermap_le_iff_le_filtercomap)
 
 lemma filterlim_base:
   "(\<And>m x. m \<in> J \<Longrightarrow> i m \<in> I) \<Longrightarrow> (\<And>m x. m \<in> J \<Longrightarrow> x \<in> F (i m) \<Longrightarrow> f x \<in> G m) \<Longrightarrow>
     LIM x (\<Sqinter>i\<in>I. principal (F i)). f x :> (\<Sqinter>j\<in>J. principal (G j))"
   by (force intro!: filterlim_INF_INF simp: image_subset_iff)
 
 lemma filterlim_base_iff:
   assumes "I \<noteq> {}" and chain: "\<And>i j. i \<in> I \<Longrightarrow> j \<in> I \<Longrightarrow> F i \<subseteq> F j \<or> F j \<subseteq> F i"
   shows "(LIM x (\<Sqinter>i\<in>I. principal (F i)). f x :> \<Sqinter>j\<in>J. principal (G j)) \<longleftrightarrow>
     (\<forall>j\<in>J. \<exists>i\<in>I. \<forall>x\<in>F i. f x \<in> G j)"
   unfolding filterlim_INF filterlim_principal
 proof (subst eventually_INF_base)
   fix i j assume "i \<in> I" "j \<in> I"
   with chain[OF this] show "\<exists>x\<in>I. principal (F x) \<le> inf (principal (F i)) (principal (F j))"
     by auto
 qed (auto simp: eventually_principal \<open>I \<noteq> {}\<close>)
 
 lemma filterlim_filtermap: "filterlim f F1 (filtermap g F2) = filterlim (\<lambda>x. f (g x)) F1 F2"
   unfolding filterlim_def filtermap_filtermap ..
 
 lemma filterlim_sup:
   "filterlim f F F1 \<Longrightarrow> filterlim f F F2 \<Longrightarrow> filterlim f F (sup F1 F2)"
   unfolding filterlim_def filtermap_sup by auto
 
 lemma filterlim_sequentially_Suc:
   "(LIM x sequentially. f (Suc x) :> F) \<longleftrightarrow> (LIM x sequentially. f x :> F)"
   unfolding filterlim_iff by (subst eventually_sequentially_Suc) simp
 
 lemma filterlim_Suc: "filterlim Suc sequentially sequentially"
   by (simp add: filterlim_iff eventually_sequentially)
 
 lemma filterlim_If:
   "LIM x inf F (principal {x. P x}). f x :> G \<Longrightarrow>
     LIM x inf F (principal {x. \<not> P x}). g x :> G \<Longrightarrow>
     LIM x F. if P x then f x else g x :> G"
   unfolding filterlim_iff eventually_inf_principal by (auto simp: eventually_conj_iff)
 
 lemma filterlim_Pair:
   "LIM x F. f x :> G \<Longrightarrow> LIM x F. g x :> H \<Longrightarrow> LIM x F. (f x, g x) :> G \<times>\<^sub>F H"
   unfolding filterlim_def
   by (rule order_trans[OF filtermap_Pair prod_filter_mono])
 
 subsection \<open>Limits to \<^const>\<open>at_top\<close> and \<^const>\<open>at_bot\<close>\<close>
 
 lemma filterlim_at_top:
   fixes f :: "'a \<Rightarrow> ('b::linorder)"
   shows "(LIM x F. f x :> at_top) \<longleftrightarrow> (\<forall>Z. eventually (\<lambda>x. Z \<le> f x) F)"
   by (auto simp: filterlim_iff eventually_at_top_linorder elim!: eventually_mono)
 
 lemma filterlim_at_top_mono:
   "LIM x F. f x :> at_top \<Longrightarrow> eventually (\<lambda>x. f x \<le> (g x::'a::linorder)) F \<Longrightarrow>
     LIM x F. g x :> at_top"
   by (auto simp: filterlim_at_top elim: eventually_elim2 intro: order_trans)
 
 lemma filterlim_at_top_dense:
   fixes f :: "'a \<Rightarrow> ('b::unbounded_dense_linorder)"
   shows "(LIM x F. f x :> at_top) \<longleftrightarrow> (\<forall>Z. eventually (\<lambda>x. Z < f x) F)"
   by (metis eventually_mono[of _ F] eventually_gt_at_top order_less_imp_le
             filterlim_at_top[of f F] filterlim_iff[of f at_top F])
 
 lemma filterlim_at_top_ge:
   fixes f :: "'a \<Rightarrow> ('b::linorder)" and c :: "'b"
   shows "(LIM x F. f x :> at_top) \<longleftrightarrow> (\<forall>Z\<ge>c. eventually (\<lambda>x. Z \<le> f x) F)"
   unfolding at_top_sub[of c] filterlim_INF by (auto simp add: filterlim_principal)
 
 lemma filterlim_at_top_at_top:
   fixes f :: "'a::linorder \<Rightarrow> 'b::linorder"
   assumes mono: "\<And>x y. Q x \<Longrightarrow> Q y \<Longrightarrow> x \<le> y \<Longrightarrow> f x \<le> f y"
   assumes bij: "\<And>x. P x \<Longrightarrow> f (g x) = x" "\<And>x. P x \<Longrightarrow> Q (g x)"
   assumes Q: "eventually Q at_top"
   assumes P: "eventually P at_top"
   shows "filterlim f at_top at_top"
 proof -
   from P obtain x where x: "\<And>y. x \<le> y \<Longrightarrow> P y"
     unfolding eventually_at_top_linorder by auto
   show ?thesis
   proof (intro filterlim_at_top_ge[THEN iffD2] allI impI)
     fix z assume "x \<le> z"
     with x have "P z" by auto
     have "eventually (\<lambda>x. g z \<le> x) at_top"
       by (rule eventually_ge_at_top)
     with Q show "eventually (\<lambda>x. z \<le> f x) at_top"
       by eventually_elim (metis mono bij \<open>P z\<close>)
   qed
 qed
 
 lemma filterlim_at_top_gt:
   fixes f :: "'a \<Rightarrow> ('b::unbounded_dense_linorder)" and c :: "'b"
   shows "(LIM x F. f x :> at_top) \<longleftrightarrow> (\<forall>Z>c. eventually (\<lambda>x. Z \<le> f x) F)"
   by (metis filterlim_at_top order_less_le_trans gt_ex filterlim_at_top_ge)
 
 lemma filterlim_at_bot:
   fixes f :: "'a \<Rightarrow> ('b::linorder)"
   shows "(LIM x F. f x :> at_bot) \<longleftrightarrow> (\<forall>Z. eventually (\<lambda>x. f x \<le> Z) F)"
   by (auto simp: filterlim_iff eventually_at_bot_linorder elim!: eventually_mono)
 
 lemma filterlim_at_bot_dense:
   fixes f :: "'a \<Rightarrow> ('b::{dense_linorder, no_bot})"
   shows "(LIM x F. f x :> at_bot) \<longleftrightarrow> (\<forall>Z. eventually (\<lambda>x. f x < Z) F)"
 proof (auto simp add: filterlim_at_bot[of f F])
   fix Z :: 'b
   from lt_ex [of Z] obtain Z' where 1: "Z' < Z" ..
   assume "\<forall>Z. eventually (\<lambda>x. f x \<le> Z) F"
   hence "eventually (\<lambda>x. f x \<le> Z') F" by auto
   thus "eventually (\<lambda>x. f x < Z) F"
     by (rule eventually_mono) (use 1 in auto)
   next
     fix Z :: 'b
     show "\<forall>Z. eventually (\<lambda>x. f x < Z) F \<Longrightarrow> eventually (\<lambda>x. f x \<le> Z) F"
       by (drule spec [of _ Z], erule eventually_mono, auto simp add: less_imp_le)
 qed
 
 lemma filterlim_at_bot_le:
   fixes f :: "'a \<Rightarrow> ('b::linorder)" and c :: "'b"
   shows "(LIM x F. f x :> at_bot) \<longleftrightarrow> (\<forall>Z\<le>c. eventually (\<lambda>x. Z \<ge> f x) F)"
   unfolding filterlim_at_bot
 proof safe
   fix Z assume *: "\<forall>Z\<le>c. eventually (\<lambda>x. Z \<ge> f x) F"
   with *[THEN spec, of "min Z c"] show "eventually (\<lambda>x. Z \<ge> f x) F"
     by (auto elim!: eventually_mono)
 qed simp
 
 lemma filterlim_at_bot_lt:
   fixes f :: "'a \<Rightarrow> ('b::unbounded_dense_linorder)" and c :: "'b"
   shows "(LIM x F. f x :> at_bot) \<longleftrightarrow> (\<forall>Z<c. eventually (\<lambda>x. Z \<ge> f x) F)"
   by (metis filterlim_at_bot filterlim_at_bot_le lt_ex order_le_less_trans)
     
 lemma filterlim_finite_subsets_at_top:
   "filterlim f (finite_subsets_at_top A) F \<longleftrightarrow>
      (\<forall>X. finite X \<and> X \<subseteq> A \<longrightarrow> eventually (\<lambda>y. finite (f y) \<and> X \<subseteq> f y \<and> f y \<subseteq> A) F)"
   (is "?lhs = ?rhs")
 proof 
   assume ?lhs
   thus ?rhs
   proof (safe, goal_cases)
     case (1 X)
     hence *: "(\<forall>\<^sub>F x in F. P (f x))" if "eventually P (finite_subsets_at_top A)" for P
       using that by (auto simp: filterlim_def le_filter_def eventually_filtermap)
     have "\<forall>\<^sub>F Y in finite_subsets_at_top A. finite Y \<and> X \<subseteq> Y \<and> Y \<subseteq> A"
       using 1 unfolding eventually_finite_subsets_at_top by force
     thus ?case by (intro *) auto
   qed
 next
   assume rhs: ?rhs
   show ?lhs unfolding filterlim_def le_filter_def eventually_finite_subsets_at_top
   proof (safe, goal_cases)
     case (1 P X)
     with rhs have "\<forall>\<^sub>F y in F. finite (f y) \<and> X \<subseteq> f y \<and> f y \<subseteq> A" by auto
     thus "eventually P (filtermap f F)" unfolding eventually_filtermap
       by eventually_elim (insert 1, auto)
   qed
 qed
 
 lemma filterlim_atMost_at_top:
   "filterlim (\<lambda>n. {..n}) (finite_subsets_at_top (UNIV :: nat set)) at_top"
   unfolding filterlim_finite_subsets_at_top
 proof (safe, goal_cases)
   case (1 X)
   then obtain n where n: "X \<subseteq> {..n}" by (auto simp: finite_nat_set_iff_bounded_le)
   show ?case using eventually_ge_at_top[of n]
     by eventually_elim (insert n, auto)
 qed
 
 lemma filterlim_lessThan_at_top:
   "filterlim (\<lambda>n. {..<n}) (finite_subsets_at_top (UNIV :: nat set)) at_top"
   unfolding filterlim_finite_subsets_at_top
 proof (safe, goal_cases)
   case (1 X)
   then obtain n where n: "X \<subseteq> {..<n}" by (auto simp: finite_nat_set_iff_bounded)
   show ?case using eventually_ge_at_top[of n]
     by eventually_elim (insert n, auto)
 qed
 
 subsection \<open>Setup \<^typ>\<open>'a filter\<close> for lifting and transfer\<close>
 
 lemma filtermap_id [simp, id_simps]: "filtermap id = id"
 by(simp add: fun_eq_iff id_def filtermap_ident)
 
 lemma filtermap_id' [simp]: "filtermap (\<lambda>x. x) = (\<lambda>F. F)"
 using filtermap_id unfolding id_def .
 
 context includes lifting_syntax
 begin
 
 definition map_filter_on :: "'a set \<Rightarrow> ('a \<Rightarrow> 'b) \<Rightarrow> 'a filter \<Rightarrow> 'b filter" where
   "map_filter_on X f F = Abs_filter (\<lambda>P. eventually (\<lambda>x. P (f x) \<and> x \<in> X) F)"
 
 lemma is_filter_map_filter_on:
   "is_filter (\<lambda>P. \<forall>\<^sub>F x in F. P (f x) \<and> x \<in> X) \<longleftrightarrow> eventually (\<lambda>x. x \<in> X) F"
 proof(rule iffI; unfold_locales)
   show "\<forall>\<^sub>F x in F. True \<and> x \<in> X" if "eventually (\<lambda>x. x \<in> X) F" using that by simp
   show "\<forall>\<^sub>F x in F. (P (f x) \<and> Q (f x)) \<and> x \<in> X" if "\<forall>\<^sub>F x in F. P (f x) \<and> x \<in> X" "\<forall>\<^sub>F x in F. Q (f x) \<and> x \<in> X" for P Q
     using eventually_conj[OF that] by(auto simp add: conj_ac cong: conj_cong)
   show "\<forall>\<^sub>F x in F. Q (f x) \<and> x \<in> X" if "\<forall>x. P x \<longrightarrow> Q x" "\<forall>\<^sub>F x in F. P (f x) \<and> x \<in> X" for P Q
     using that(2) by(rule eventually_mono)(use that(1) in auto)
   show "eventually (\<lambda>x. x \<in> X) F" if "is_filter (\<lambda>P. \<forall>\<^sub>F x in F. P (f x) \<and> x \<in> X)"
     using is_filter.True[OF that] by simp
 qed
 
 lemma eventually_map_filter_on: "eventually P (map_filter_on X f F) = (\<forall>\<^sub>F x in F. P (f x) \<and> x \<in> X)"
   if "eventually (\<lambda>x. x \<in> X) F"
   by(simp add: is_filter_map_filter_on map_filter_on_def eventually_Abs_filter that)
 
 lemma map_filter_on_UNIV: "map_filter_on UNIV = filtermap"
   by(simp add: map_filter_on_def filtermap_def fun_eq_iff)
 
 lemma map_filter_on_comp: "map_filter_on X f (map_filter_on Y g F) = map_filter_on Y (f \<circ> g) F"
   if "g ` Y \<subseteq> X" and "eventually (\<lambda>x. x \<in> Y) F"
   unfolding map_filter_on_def using that(1)
   by(auto simp add: eventually_Abs_filter that(2) is_filter_map_filter_on intro!: arg_cong[where f=Abs_filter] arg_cong2[where f=eventually])
 
 inductive rel_filter :: "('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> 'a filter \<Rightarrow> 'b filter \<Rightarrow> bool" for R F G where
   "rel_filter R F G" if "eventually (case_prod R) Z" "map_filter_on {(x, y). R x y} fst Z = F" "map_filter_on {(x, y). R x y} snd Z = G"
 
 lemma rel_filter_eq [relator_eq]: "rel_filter (=) = (=)"
 proof(intro ext iffI)+
   show "F = G" if "rel_filter (=) F G" for F G using that
     by cases(clarsimp simp add: filter_eq_iff eventually_map_filter_on split_def cong: rev_conj_cong)
   show "rel_filter (=) F G" if "F = G" for F G unfolding \<open>F = G\<close>
   proof
     let ?Z = "map_filter_on UNIV (\<lambda>x. (x, x)) G"
     have [simp]: "range (\<lambda>x. (x, x)) \<subseteq> {(x, y). x = y}" by auto
     show "map_filter_on {(x, y). x = y} fst ?Z = G" and "map_filter_on {(x, y). x = y} snd ?Z = G"
       by(simp_all add: map_filter_on_comp)(simp_all add: map_filter_on_UNIV o_def)
     show "\<forall>\<^sub>F (x, y) in ?Z. x = y" by(simp add: eventually_map_filter_on)
   qed
 qed
 
 lemma rel_filter_mono [relator_mono]: "rel_filter A \<le> rel_filter B" if le: "A \<le> B"
 proof(clarify elim!: rel_filter.cases)
   show "rel_filter B (map_filter_on {(x, y). A x y} fst Z) (map_filter_on {(x, y). A x y} snd Z)"
     (is "rel_filter _ ?X ?Y") if "\<forall>\<^sub>F (x, y) in Z. A x y" for Z
   proof
     let ?Z = "map_filter_on {(x, y). A x y} id Z"
     show "\<forall>\<^sub>F (x, y) in ?Z. B x y" using le that
       by(simp add: eventually_map_filter_on le_fun_def split_def conj_commute cong: conj_cong)
     have [simp]: "{(x, y). A x y} \<subseteq> {(x, y). B x y}" using le by auto
     show "map_filter_on {(x, y). B x y} fst ?Z = ?X" "map_filter_on {(x, y). B x y} snd ?Z = ?Y"
       using le that by(simp_all add: le_fun_def map_filter_on_comp)
   qed
 qed
 
 lemma rel_filter_conversep: "rel_filter A\<inverse>\<inverse> = (rel_filter A)\<inverse>\<inverse>"
 proof(safe intro!: ext elim!: rel_filter.cases)
   show *: "rel_filter A (map_filter_on {(x, y). A\<inverse>\<inverse> x y} snd Z) (map_filter_on {(x, y). A\<inverse>\<inverse> x y} fst Z)"
     (is "rel_filter _ ?X ?Y") if "\<forall>\<^sub>F (x, y) in Z. A\<inverse>\<inverse> x y" for A Z
   proof
     let ?Z = "map_filter_on {(x, y). A y x} prod.swap Z"
     show "\<forall>\<^sub>F (x, y) in ?Z. A x y" using that by(simp add: eventually_map_filter_on)
     have [simp]: "prod.swap ` {(x, y). A y x} \<subseteq> {(x, y). A x y}" by auto
     show "map_filter_on {(x, y). A x y} fst ?Z = ?X" "map_filter_on {(x, y). A x y} snd ?Z = ?Y"
       using that by(simp_all add: map_filter_on_comp o_def)
   qed
   show "rel_filter A\<inverse>\<inverse> (map_filter_on {(x, y). A x y} snd Z) (map_filter_on {(x, y). A x y} fst Z)"
     if "\<forall>\<^sub>F (x, y) in Z. A x y" for Z using *[of "A\<inverse>\<inverse>" Z] that by simp
 qed
 
 lemma rel_filter_distr [relator_distr]:
   "rel_filter A OO rel_filter B = rel_filter (A OO B)"
 proof(safe intro!: ext elim!: rel_filter.cases)
   let ?AB = "{(x, y). (A OO B) x y}"
   show "(rel_filter A OO rel_filter B)
      (map_filter_on {(x, y). (A OO B) x y} fst Z) (map_filter_on {(x, y). (A OO B) x y} snd Z)"
     (is "(_ OO _) ?F ?H") if "\<forall>\<^sub>F (x, y) in Z. (A OO B) x y" for Z
   proof
     let ?G = "map_filter_on ?AB (\<lambda>(x, y). SOME z. A x z \<and> B z y) Z"
     show "rel_filter A ?F ?G"
     proof
       let ?Z = "map_filter_on ?AB (\<lambda>(x, y). (x, SOME z. A x z \<and> B z y)) Z"
       show "\<forall>\<^sub>F (x, y) in ?Z. A x y" using that
         by(auto simp add: eventually_map_filter_on split_def elim!: eventually_mono intro: someI2)
       have [simp]: "(\<lambda>p. (fst p, SOME z. A (fst p) z \<and> B z (snd p))) ` {p. (A OO B) (fst p) (snd p)} \<subseteq> {p. A (fst p) (snd p)}" by(auto intro: someI2)
       show "map_filter_on {(x, y). A x y} fst ?Z = ?F" "map_filter_on {(x, y). A x y} snd ?Z = ?G"
         using that by(simp_all add: map_filter_on_comp split_def o_def)
     qed
     show "rel_filter B ?G ?H"
     proof
       let ?Z = "map_filter_on ?AB (\<lambda>(x, y). (SOME z. A x z \<and> B z y, y)) Z"
       show "\<forall>\<^sub>F (x, y) in ?Z. B x y" using that
         by(auto simp add: eventually_map_filter_on split_def elim!: eventually_mono intro: someI2)
       have [simp]: "(\<lambda>p. (SOME z. A (fst p) z \<and> B z (snd p), snd p)) ` {p. (A OO B) (fst p) (snd p)} \<subseteq> {p. B (fst p) (snd p)}" by(auto intro: someI2)
       show "map_filter_on {(x, y). B x y} fst ?Z = ?G" "map_filter_on {(x, y). B x y} snd ?Z = ?H"
         using that by(simp_all add: map_filter_on_comp split_def o_def)
     qed
   qed
 
   fix F G
   assume F: "\<forall>\<^sub>F (x, y) in F. A x y" and G: "\<forall>\<^sub>F (x, y) in G. B x y"
     and eq: "map_filter_on {(x, y). B x y} fst G = map_filter_on {(x, y). A x y} snd F" (is "?Y2 = ?Y1")
   let ?X = "map_filter_on {(x, y). A x y} fst F"
     and ?Z = "(map_filter_on {(x, y). B x y} snd G)"
   have step: "\<exists>P'\<le>P. \<exists>Q' \<le> Q. eventually P' F \<and> eventually Q' G \<and> {y. \<exists>x. P' (x, y)} = {y. \<exists>z. Q' (y, z)}"
     if P: "eventually P F" and Q: "eventually Q G" for P Q
   proof -
     let ?P = "\<lambda>(x, y). P (x, y) \<and> A x y" and ?Q = "\<lambda>(y, z). Q (y, z) \<and> B y z"
     define P' where "P' \<equiv> \<lambda>(x, y). ?P (x, y) \<and> (\<exists>z. ?Q (y, z))"
     define Q' where "Q' \<equiv> \<lambda>(y, z). ?Q (y, z) \<and> (\<exists>x. ?P (x, y))"
     have "P' \<le> P" "Q' \<le> Q" "{y. \<exists>x. P' (x, y)} = {y. \<exists>z. Q' (y, z)}"
       by(auto simp add: P'_def Q'_def)
     moreover
     from P Q F G have P': "eventually ?P F" and Q': "eventually ?Q G" 
       by(simp_all add: eventually_conj_iff split_def)
     from P' F have "\<forall>\<^sub>F y in ?Y1. \<exists>x. P (x, y) \<and> A x y"
       by(auto simp add: eventually_map_filter_on elim!: eventually_mono)
     from this[folded eq] obtain Q'' where Q'': "eventually Q'' G"
       and Q''P: "{y. \<exists>z. Q'' (y, z)} \<subseteq> {y. \<exists>x. ?P (x, y)}"
       using G by(fastforce simp add: eventually_map_filter_on)
     have "eventually (inf Q'' ?Q) G" using Q'' Q' by(auto intro: eventually_conj simp add: inf_fun_def)
     then have "eventually Q' G" using Q''P  by(auto elim!: eventually_mono simp add: Q'_def)
     moreover
     from Q' G have "\<forall>\<^sub>F y in ?Y2. \<exists>z. Q (y, z) \<and> B y z"
       by(auto simp add: eventually_map_filter_on elim!: eventually_mono)
     from this[unfolded eq] obtain P'' where P'': "eventually P'' F"
       and P''Q: "{y. \<exists>x. P'' (x, y)} \<subseteq> {y. \<exists>z. ?Q (y, z)}"
       using F by(fastforce simp add: eventually_map_filter_on)
     have "eventually (inf P'' ?P) F" using P'' P' by(auto intro: eventually_conj simp add: inf_fun_def)
     then have "eventually P' F" using P''Q  by(auto elim!: eventually_mono simp add: P'_def)
     ultimately show ?thesis by blast
   qed
 
   show "rel_filter (A OO B) ?X ?Z"
   proof
     let ?Y = "\<lambda>Y. \<exists>X Z. eventually X ?X \<and> eventually Z ?Z \<and> (\<lambda>(x, z). X x \<and> Z z \<and> (A OO B) x z) \<le> Y"
     have Y: "is_filter ?Y"
     proof
       show "?Y (\<lambda>_. True)" by(auto simp add: le_fun_def intro: eventually_True)
       show "?Y (\<lambda>x. P x \<and> Q x)" if "?Y P" "?Y Q" for P Q using that
         apply clarify
         apply(intro exI conjI; (elim eventually_rev_mp; fold imp_conjL; intro always_eventually allI; rule imp_refl)?)
         apply auto
         done
       show "?Y Q" if "?Y P" "\<forall>x. P x \<longrightarrow> Q x" for P Q using that by blast
     qed
     define Y where "Y = Abs_filter ?Y"
     have eventually_Y: "eventually P Y \<longleftrightarrow> ?Y P" for P
       using eventually_Abs_filter[OF Y, of P] by(simp add: Y_def)
     show YY: "\<forall>\<^sub>F (x, y) in Y. (A OO B) x y" using F G
       by(auto simp add: eventually_Y eventually_map_filter_on eventually_conj_iff intro!: eventually_True)
     have "?Y (\<lambda>(x, z). P x \<and> (A OO B) x z) \<longleftrightarrow> (\<forall>\<^sub>F (x, y) in F. P x \<and> A x y)" (is "?lhs = ?rhs") for P
     proof
       show ?lhs if ?rhs using G F that
         by(auto 4 3 intro: exI[where x="\<lambda>_. True"] simp add: eventually_map_filter_on split_def)
       assume ?lhs
       then obtain X Z where "\<forall>\<^sub>F (x, y) in F. X x \<and> A x y"
         and "\<forall>\<^sub>F (x, y) in G. Z y \<and> B x y"
         and "(\<lambda>(x, z). X x \<and> Z z \<and> (A OO B) x z) \<le> (\<lambda>(x, z). P x \<and> (A OO B) x z)"
         using F G by(auto simp add: eventually_map_filter_on split_def)
       from step[OF this(1, 2)] this(3)
       show ?rhs by(clarsimp elim!: eventually_rev_mp simp add: le_fun_def)(fastforce intro: always_eventually)
     qed
     then show "map_filter_on ?AB fst Y = ?X"
       by(simp add: filter_eq_iff YY eventually_map_filter_on)(simp add: eventually_Y eventually_map_filter_on F G; simp add: split_def)
 
     have "?Y (\<lambda>(x, z). P z \<and> (A OO B) x z) \<longleftrightarrow> (\<forall>\<^sub>F (x, y) in G. P y \<and> B x y)" (is "?lhs = ?rhs") for P
     proof
       show ?lhs if ?rhs using G F that
         by(auto 4 3 intro: exI[where x="\<lambda>_. True"] simp add: eventually_map_filter_on split_def)
       assume ?lhs
       then obtain X Z where "\<forall>\<^sub>F (x, y) in F. X x \<and> A x y"
         and "\<forall>\<^sub>F (x, y) in G. Z y \<and> B x y"
         and "(\<lambda>(x, z). X x \<and> Z z \<and> (A OO B) x z) \<le> (\<lambda>(x, z). P z \<and> (A OO B) x z)"
         using F G by(auto simp add: eventually_map_filter_on split_def)
       from step[OF this(1, 2)] this(3)
       show ?rhs by(clarsimp elim!: eventually_rev_mp simp add: le_fun_def)(fastforce intro: always_eventually)
     qed
     then show "map_filter_on ?AB snd Y = ?Z"
       by(simp add: filter_eq_iff YY eventually_map_filter_on)(simp add: eventually_Y eventually_map_filter_on F G; simp add: split_def)
   qed
 qed
 
 lemma filtermap_parametric: "((A ===> B) ===> rel_filter A ===> rel_filter B) filtermap filtermap"
 proof(intro rel_funI; erule rel_filter.cases; hypsubst)
   fix f g Z
   assume fg: "(A ===> B) f g" and Z: "\<forall>\<^sub>F (x, y) in Z. A x y"
   have "rel_filter B (map_filter_on {(x, y). A x y} (f \<circ> fst) Z) (map_filter_on {(x, y). A x y} (g \<circ> snd) Z)"
     (is "rel_filter _ ?F ?G")
   proof
     let ?Z = "map_filter_on {(x, y). A x y} (map_prod f g) Z"
     show "\<forall>\<^sub>F (x, y) in ?Z. B x y" using fg Z
       by(auto simp add: eventually_map_filter_on split_def elim!: eventually_mono rel_funD)
     have [simp]: "map_prod f g ` {p. A (fst p) (snd p)} \<subseteq> {p. B (fst p) (snd p)}"
       using fg by(auto dest: rel_funD)
     show "map_filter_on {(x, y). B x y} fst ?Z = ?F" "map_filter_on {(x, y). B x y} snd ?Z = ?G"
       using Z by(auto simp add: map_filter_on_comp split_def)
   qed
   thus "rel_filter B (filtermap f (map_filter_on {(x, y). A x y} fst Z)) (filtermap g (map_filter_on {(x, y). A x y} snd Z))"
     using Z by(simp add: map_filter_on_UNIV[symmetric] map_filter_on_comp)
 qed
 
 lemma rel_filter_Grp: "rel_filter (Grp UNIV f) = Grp UNIV (filtermap f)"
 proof((intro antisym predicate2I; (elim GrpE; hypsubst)?), rule GrpI[OF _ UNIV_I])
   fix F G
   assume "rel_filter (Grp UNIV f) F G"
   hence "rel_filter (=) (filtermap f F) (filtermap id G)"
     by(rule filtermap_parametric[THEN rel_funD, THEN rel_funD, rotated])(simp add: Grp_def rel_fun_def)
   thus "filtermap f F = G" by(simp add: rel_filter_eq)
 next
   fix F :: "'a filter"
   have "rel_filter (=) F F" by(simp add: rel_filter_eq)
   hence "rel_filter (Grp UNIV f) (filtermap id F) (filtermap f F)"
     by(rule filtermap_parametric[THEN rel_funD, THEN rel_funD, rotated])(simp add: Grp_def rel_fun_def)
   thus "rel_filter (Grp UNIV f) F (filtermap f F)" by simp
 qed
 
 lemma Quotient_filter [quot_map]:
   "Quotient R Abs Rep T \<Longrightarrow> Quotient (rel_filter R) (filtermap Abs) (filtermap Rep) (rel_filter T)"
   unfolding Quotient_alt_def5 rel_filter_eq[symmetric] rel_filter_Grp[symmetric]
   by(simp add: rel_filter_distr[symmetric] rel_filter_conversep[symmetric] rel_filter_mono)
 
 lemma left_total_rel_filter [transfer_rule]: "left_total A \<Longrightarrow> left_total (rel_filter A)"
 unfolding left_total_alt_def rel_filter_eq[symmetric] rel_filter_conversep[symmetric] rel_filter_distr
 by(rule rel_filter_mono)
 
 lemma right_total_rel_filter [transfer_rule]: "right_total A \<Longrightarrow> right_total (rel_filter A)"
 using left_total_rel_filter[of "A\<inverse>\<inverse>"] by(simp add: rel_filter_conversep)
 
 lemma bi_total_rel_filter [transfer_rule]: "bi_total A \<Longrightarrow> bi_total (rel_filter A)"
 unfolding bi_total_alt_def by(simp add: left_total_rel_filter right_total_rel_filter)
 
 lemma left_unique_rel_filter [transfer_rule]: "left_unique A \<Longrightarrow> left_unique (rel_filter A)"
 unfolding left_unique_alt_def rel_filter_eq[symmetric] rel_filter_conversep[symmetric] rel_filter_distr
 by(rule rel_filter_mono)
 
 lemma right_unique_rel_filter [transfer_rule]:
   "right_unique A \<Longrightarrow> right_unique (rel_filter A)"
 using left_unique_rel_filter[of "A\<inverse>\<inverse>"] by(simp add: rel_filter_conversep)
 
 lemma bi_unique_rel_filter [transfer_rule]: "bi_unique A \<Longrightarrow> bi_unique (rel_filter A)"
 by(simp add: bi_unique_alt_def left_unique_rel_filter right_unique_rel_filter)
 
 lemma eventually_parametric [transfer_rule]:
   "((A ===> (=)) ===> rel_filter A ===> (=)) eventually eventually"
 by(auto 4 4 intro!: rel_funI elim!: rel_filter.cases simp add: eventually_map_filter_on dest: rel_funD intro: always_eventually elim!: eventually_rev_mp)
 
 lemma frequently_parametric [transfer_rule]: "((A ===> (=)) ===> rel_filter A ===> (=)) frequently frequently"
   unfolding frequently_def[abs_def] by transfer_prover
 
 lemma is_filter_parametric [transfer_rule]:
   assumes [transfer_rule]: "bi_total A"
   assumes [transfer_rule]: "bi_unique A"
   shows "(((A ===> (=)) ===> (=)) ===> (=)) is_filter is_filter"
   unfolding is_filter_def by transfer_prover
 
 lemma top_filter_parametric [transfer_rule]: "rel_filter A top top" if "bi_total A"
 proof
   let ?Z = "principal {(x, y). A x y}"
   show "\<forall>\<^sub>F (x, y) in ?Z. A x y" by(simp add: eventually_principal)
   show "map_filter_on {(x, y). A x y} fst ?Z = top" "map_filter_on {(x, y). A x y} snd ?Z = top"
     using that by(auto simp add: filter_eq_iff eventually_map_filter_on eventually_principal bi_total_def)
 qed
 
 lemma bot_filter_parametric [transfer_rule]: "rel_filter A bot bot"
 proof
   show "\<forall>\<^sub>F (x, y) in bot. A x y" by simp
   show "map_filter_on {(x, y). A x y} fst bot = bot" "map_filter_on {(x, y). A x y} snd bot = bot"
     by(simp_all add: filter_eq_iff eventually_map_filter_on)
 qed
 
 lemma principal_parametric [transfer_rule]: "(rel_set A ===> rel_filter A) principal principal"
 proof(rule rel_funI rel_filter.intros)+
   fix S S'
   assume *: "rel_set A S S'"
   define SS' where "SS' = S \<times> S' \<inter> {(x, y). A x y}"
   have SS': "SS' \<subseteq> {(x, y). A x y}" and [simp]: "S = fst ` SS'" "S' = snd ` SS'"
     using * by(auto 4 3 dest: rel_setD1 rel_setD2 intro: rev_image_eqI simp add: SS'_def)
   let ?Z = "principal SS'"
   show "\<forall>\<^sub>F (x, y) in ?Z. A x y" using SS' by(auto simp add: eventually_principal)
   then show "map_filter_on {(x, y). A x y} fst ?Z = principal S"
     and "map_filter_on {(x, y). A x y} snd ?Z = principal S'"
     by(auto simp add: filter_eq_iff eventually_map_filter_on eventually_principal)
 qed
 
 lemma sup_filter_parametric [transfer_rule]:
   "(rel_filter A ===> rel_filter A ===> rel_filter A) sup sup"
 proof(intro rel_funI; elim rel_filter.cases; hypsubst)
   show "rel_filter A
     (map_filter_on {(x, y). A x y} fst FG \<squnion> map_filter_on {(x, y). A x y} fst FG')
     (map_filter_on {(x, y). A x y} snd FG \<squnion> map_filter_on {(x, y). A x y} snd FG')"
     (is "rel_filter _ (sup ?F ?G) (sup ?F' ?G')")
     if "\<forall>\<^sub>F (x, y) in FG. A x y" "\<forall>\<^sub>F (x, y) in FG'. A x y" for FG FG'
   proof
     let ?Z = "sup FG FG'"
     show "\<forall>\<^sub>F (x, y) in ?Z. A x y" by(simp add: eventually_sup that)
     then show "map_filter_on {(x, y). A x y} fst ?Z = sup ?F ?G" 
       and "map_filter_on {(x, y). A x y} snd ?Z = sup ?F' ?G'"
       by(simp_all add: filter_eq_iff eventually_map_filter_on eventually_sup)
   qed
 qed
 
 lemma Sup_filter_parametric [transfer_rule]: "(rel_set (rel_filter A) ===> rel_filter A) Sup Sup"
 proof(rule rel_funI)
   fix S S'
   define SS' where "SS' = S \<times> S' \<inter> {(F, G). rel_filter A F G}"
   assume "rel_set (rel_filter A) S S'"
   then have SS': "SS' \<subseteq> {(F, G). rel_filter A F G}" and [simp]: "S = fst ` SS'" "S' = snd ` SS'"
     by(auto 4 3 dest: rel_setD1 rel_setD2 intro: rev_image_eqI simp add: SS'_def)
   from SS' obtain Z where Z: "\<And>F G. (F, G) \<in> SS' \<Longrightarrow>
     (\<forall>\<^sub>F (x, y) in Z F G. A x y) \<and>
     id F = map_filter_on {(x, y). A x y} fst (Z F G) \<and>
     id G = map_filter_on {(x, y). A x y} snd (Z F G)"
     unfolding rel_filter.simps by atomize_elim((rule choice allI)+; auto)
   have id: "eventually P F = eventually P (id F)" "eventually Q G = eventually Q (id G)"
     if "(F, G) \<in> SS'" for P Q F G by simp_all
   show "rel_filter A (Sup S) (Sup S')"
   proof
     let ?Z = "\<Squnion>(F, G)\<in>SS'. Z F G"
     show *: "\<forall>\<^sub>F (x, y) in ?Z. A x y" using Z by(auto simp add: eventually_Sup)
     show "map_filter_on {(x, y). A x y} fst ?Z = Sup S" "map_filter_on {(x, y). A x y} snd ?Z = Sup S'"
       unfolding filter_eq_iff
       by(auto 4 4 simp add: id eventually_Sup eventually_map_filter_on *[simplified eventually_Sup] simp del: id_apply dest: Z)
   qed
 qed
 
 context
   fixes A :: "'a \<Rightarrow> 'b \<Rightarrow> bool"
   assumes [transfer_rule]: "bi_unique A"
 begin
 
 lemma le_filter_parametric [transfer_rule]:
   "(rel_filter A ===> rel_filter A ===> (=)) (\<le>) (\<le>)"
 unfolding le_filter_def[abs_def] by transfer_prover
 
 lemma less_filter_parametric [transfer_rule]:
   "(rel_filter A ===> rel_filter A ===> (=)) (<) (<)"
 unfolding less_filter_def[abs_def] by transfer_prover
 
 context
   assumes [transfer_rule]: "bi_total A"
 begin
 
 lemma Inf_filter_parametric [transfer_rule]:
   "(rel_set (rel_filter A) ===> rel_filter A) Inf Inf"
 unfolding Inf_filter_def[abs_def] by transfer_prover
 
 lemma inf_filter_parametric [transfer_rule]:
   "(rel_filter A ===> rel_filter A ===> rel_filter A) inf inf"
 proof(intro rel_funI)+
   fix F F' G G'
   assume [transfer_rule]: "rel_filter A F F'" "rel_filter A G G'"
   have "rel_filter A (Inf {F, G}) (Inf {F', G'})" by transfer_prover
   thus "rel_filter A (inf F G) (inf F' G')" by simp
 qed
 
 end
 
 end
 
 end
 
 context
   includes lifting_syntax
 begin
 
 lemma prod_filter_parametric [transfer_rule]:
    "(rel_filter R ===> rel_filter S ===> rel_filter (rel_prod R S)) prod_filter prod_filter"
 proof(intro rel_funI; elim rel_filter.cases; hypsubst)
   fix F G
   assume F: "\<forall>\<^sub>F (x, y) in F. R x y" and G: "\<forall>\<^sub>F (x, y) in G. S x y"
   show "rel_filter (rel_prod R S)
     (map_filter_on {(x, y). R x y} fst F \<times>\<^sub>F map_filter_on {(x, y). S x y} fst G)
     (map_filter_on {(x, y). R x y} snd F \<times>\<^sub>F map_filter_on {(x, y). S x y} snd G)"
     (is "rel_filter ?RS ?F ?G")
   proof
     let ?Z = "filtermap (\<lambda>((a, b), (a', b')). ((a, a'), (b, b'))) (prod_filter F G)"
     show *: "\<forall>\<^sub>F (x, y) in ?Z. rel_prod R S x y" using F G
       by(auto simp add: eventually_filtermap split_beta eventually_prod_filter)
     show "map_filter_on {(x, y). ?RS x y} fst ?Z = ?F"
       using F G
       apply(clarsimp simp add: filter_eq_iff eventually_map_filter_on *)
       apply(simp add: eventually_filtermap split_beta eventually_prod_filter)
       apply(subst eventually_map_filter_on; simp)+
       apply(rule iffI; clarsimp)
       subgoal for P P' P''
         apply(rule exI[where x="\<lambda>a. \<exists>b. P' (a, b) \<and> R a b"]; rule conjI)
         subgoal by(fastforce elim: eventually_rev_mp eventually_mono)
         subgoal
           by(rule exI[where x="\<lambda>a. \<exists>b. P'' (a, b) \<and> S a b"])(fastforce elim: eventually_rev_mp eventually_mono)
         done
       subgoal by fastforce
       done
     show "map_filter_on {(x, y). ?RS x y} snd ?Z = ?G"
       using F G
       apply(clarsimp simp add: filter_eq_iff eventually_map_filter_on *)
       apply(simp add: eventually_filtermap split_beta eventually_prod_filter)
       apply(subst eventually_map_filter_on; simp)+
       apply(rule iffI; clarsimp)
       subgoal for P P' P''
         apply(rule exI[where x="\<lambda>b. \<exists>a. P' (a, b) \<and> R a b"]; rule conjI)
         subgoal by(fastforce elim: eventually_rev_mp eventually_mono)
         subgoal
           by(rule exI[where x="\<lambda>b. \<exists>a. P'' (a, b) \<and> S a b"])(fastforce elim: eventually_rev_mp eventually_mono)
         done
       subgoal by fastforce
       done
   qed
 qed
 
 end
 
 
 text \<open>Code generation for filters\<close>
 
 definition abstract_filter :: "(unit \<Rightarrow> 'a filter) \<Rightarrow> 'a filter"
   where [simp]: "abstract_filter f = f ()"
 
 code_datatype principal abstract_filter
 
 hide_const (open) abstract_filter
 
 declare [[code drop: filterlim prod_filter filtermap eventually
   "inf :: _ filter \<Rightarrow> _" "sup :: _ filter \<Rightarrow> _" "less_eq :: _ filter \<Rightarrow> _"
   Abs_filter]]
 
 declare filterlim_principal [code]
 declare principal_prod_principal [code]
 declare filtermap_principal [code]
 declare filtercomap_principal [code]
 declare eventually_principal [code]
 declare inf_principal [code]
 declare sup_principal [code]
 declare principal_le_iff [code]
 
 lemma Rep_filter_iff_eventually [simp, code]:
   "Rep_filter F P \<longleftrightarrow> eventually P F"
   by (simp add: eventually_def)
 
 lemma bot_eq_principal_empty [code]:
   "bot = principal {}"
   by simp
 
 lemma top_eq_principal_UNIV [code]:
   "top = principal UNIV"
   by simp
 
 instantiation filter :: (equal) equal
 begin
 
 definition equal_filter :: "'a filter \<Rightarrow> 'a filter \<Rightarrow> bool"
   where "equal_filter F F' \<longleftrightarrow> F = F'"
 
 lemma equal_filter [code]:
   "HOL.equal (principal A) (principal B) \<longleftrightarrow> A = B"
   by (simp add: equal_filter_def)
 
 instance
   by standard (simp add: equal_filter_def)
 
 end
 
 end
diff --git a/src/HOL/Library/Countable_Set.thy b/src/HOL/Library/Countable_Set.thy
--- a/src/HOL/Library/Countable_Set.thy
+++ b/src/HOL/Library/Countable_Set.thy
@@ -1,450 +1,451 @@
 (*  Title:      HOL/Library/Countable_Set.thy
     Author:     Johannes Hölzl
     Author:     Andrei Popescu
 *)
 
 section \<open>Countable sets\<close>
 
 theory Countable_Set
 imports Countable Infinite_Set
 begin
 
 subsection \<open>Predicate for countable sets\<close>
 
 definition countable :: "'a set \<Rightarrow> bool" where
   "countable S \<longleftrightarrow> (\<exists>f::'a \<Rightarrow> nat. inj_on f S)"
 
 lemma countableE:
   assumes S: "countable S" obtains f :: "'a \<Rightarrow> nat" where "inj_on f S"
   using S by (auto simp: countable_def)
 
 lemma countableI: "inj_on (f::'a \<Rightarrow> nat) S \<Longrightarrow> countable S"
   by (auto simp: countable_def)
 
 lemma countableI': "inj_on (f::'a \<Rightarrow> 'b::countable) S \<Longrightarrow> countable S"
   using comp_inj_on[of f S to_nat] by (auto intro: countableI)
 
 lemma countableE_bij:
   assumes S: "countable S" obtains f :: "nat \<Rightarrow> 'a" and C :: "nat set" where "bij_betw f C S"
   using S by (blast elim: countableE dest: inj_on_imp_bij_betw bij_betw_inv)
 
 lemma countableI_bij: "bij_betw f (C::nat set) S \<Longrightarrow> countable S"
   by (blast intro: countableI bij_betw_inv_into bij_betw_imp_inj_on)
 
 lemma countable_finite: "finite S \<Longrightarrow> countable S"
   by (blast dest: finite_imp_inj_to_nat_seg countableI)
 
 lemma countableI_bij1: "bij_betw f A B \<Longrightarrow> countable A \<Longrightarrow> countable B"
   by (blast elim: countableE_bij intro: bij_betw_trans countableI_bij)
 
 lemma countableI_bij2: "bij_betw f B A \<Longrightarrow> countable A \<Longrightarrow> countable B"
   by (blast elim: countableE_bij intro: bij_betw_trans bij_betw_inv_into countableI_bij)
 
 lemma countable_iff_bij[simp]: "bij_betw f A B \<Longrightarrow> countable A \<longleftrightarrow> countable B"
   by (blast intro: countableI_bij1 countableI_bij2)
 
 lemma countable_subset: "A \<subseteq> B \<Longrightarrow> countable B \<Longrightarrow> countable A"
   by (auto simp: countable_def intro: subset_inj_on)
 
 lemma countableI_type[intro, simp]: "countable (A:: 'a :: countable set)"
   using countableI[of to_nat A] by auto
 
 subsection \<open>Enumerate a countable set\<close>
 
 lemma countableE_infinite:
   assumes "countable S" "infinite S"
   obtains e :: "'a \<Rightarrow> nat" where "bij_betw e S UNIV"
 proof -
   obtain f :: "'a \<Rightarrow> nat" where "inj_on f S"
     using \<open>countable S\<close> by (rule countableE)
   then have "bij_betw f S (f`S)"
     unfolding bij_betw_def by simp
   moreover
   from \<open>inj_on f S\<close> \<open>infinite S\<close> have inf_fS: "infinite (f`S)"
     by (auto dest: finite_imageD)
   then have "bij_betw (the_inv_into UNIV (enumerate (f`S))) (f`S) UNIV"
     by (intro bij_betw_the_inv_into bij_enumerate)
   ultimately have "bij_betw (the_inv_into UNIV (enumerate (f`S)) \<circ> f) S UNIV"
     by (rule bij_betw_trans)
   then show thesis ..
 qed
 
 lemma countable_infiniteE':
   assumes "countable A" "infinite A"
   obtains g where "bij_betw g (UNIV :: nat set) A"
   using bij_betw_inv[OF countableE_infinite[OF assms]] that by blast
 
 lemma countable_enum_cases:
   assumes "countable S"
   obtains (finite) f :: "'a \<Rightarrow> nat" where "finite S" "bij_betw f S {..<card S}"
         | (infinite) f :: "'a \<Rightarrow> nat" where "infinite S" "bij_betw f S UNIV"
   using ex_bij_betw_finite_nat[of S] countableE_infinite \<open>countable S\<close>
   by (cases "finite S") (auto simp add: atLeast0LessThan)
 
 definition to_nat_on :: "'a set \<Rightarrow> 'a \<Rightarrow> nat" where
   "to_nat_on S = (SOME f. if finite S then bij_betw f S {..< card S} else bij_betw f S UNIV)"
 
 definition from_nat_into :: "'a set \<Rightarrow> nat \<Rightarrow> 'a" where
   "from_nat_into S n = (if n \<in> to_nat_on S ` S then inv_into S (to_nat_on S) n else SOME s. s\<in>S)"
 
 lemma to_nat_on_finite: "finite S \<Longrightarrow> bij_betw (to_nat_on S) S {..< card S}"
   using ex_bij_betw_finite_nat unfolding to_nat_on_def
   by (intro someI2_ex[where Q="\<lambda>f. bij_betw f S {..<card S}"]) (auto simp add: atLeast0LessThan)
 
 lemma to_nat_on_infinite: "countable S \<Longrightarrow> infinite S \<Longrightarrow> bij_betw (to_nat_on S) S UNIV"
   using countableE_infinite unfolding to_nat_on_def
   by (intro someI2_ex[where Q="\<lambda>f. bij_betw f S UNIV"]) auto
 
 lemma bij_betw_from_nat_into_finite: "finite S \<Longrightarrow> bij_betw (from_nat_into S) {..< card S} S"
   unfolding from_nat_into_def[abs_def]
   using to_nat_on_finite[of S]
   apply (subst bij_betw_cong)
   apply (split if_split)
   apply (simp add: bij_betw_def)
   apply (auto cong: bij_betw_cong
               intro: bij_betw_inv_into to_nat_on_finite)
   done
 
 lemma bij_betw_from_nat_into: "countable S \<Longrightarrow> infinite S \<Longrightarrow> bij_betw (from_nat_into S) UNIV S"
   unfolding from_nat_into_def[abs_def]
   using to_nat_on_infinite[of S, unfolded bij_betw_def]
   by (auto cong: bij_betw_cong intro: bij_betw_inv_into to_nat_on_infinite)
 
 lemma countable_as_injective_image:
   assumes "countable A" "infinite A"
   obtains f :: "nat \<Rightarrow> 'a" where "A = range f" "inj f"
 by (metis bij_betw_def bij_betw_from_nat_into [OF assms])
 
 lemma inj_on_to_nat_on[intro]: "countable A \<Longrightarrow> inj_on (to_nat_on A) A"
   using to_nat_on_infinite[of A] to_nat_on_finite[of A]
   by (cases "finite A") (auto simp: bij_betw_def)
 
 lemma to_nat_on_inj[simp]:
   "countable A \<Longrightarrow> a \<in> A \<Longrightarrow> b \<in> A \<Longrightarrow> to_nat_on A a = to_nat_on A b \<longleftrightarrow> a = b"
   using inj_on_to_nat_on[of A] by (auto dest: inj_onD)
 
 lemma from_nat_into_to_nat_on[simp]: "countable A \<Longrightarrow> a \<in> A \<Longrightarrow> from_nat_into A (to_nat_on A a) = a"
   by (auto simp: from_nat_into_def intro!: inv_into_f_f)
 
 lemma subset_range_from_nat_into: "countable A \<Longrightarrow> A \<subseteq> range (from_nat_into A)"
   by (auto intro: from_nat_into_to_nat_on[symmetric])
 
 lemma from_nat_into: "A \<noteq> {} \<Longrightarrow> from_nat_into A n \<in> A"
   unfolding from_nat_into_def by (metis equals0I inv_into_into someI_ex)
 
 lemma range_from_nat_into_subset: "A \<noteq> {} \<Longrightarrow> range (from_nat_into A) \<subseteq> A"
   using from_nat_into[of A] by auto
 
 lemma range_from_nat_into[simp]: "A \<noteq> {} \<Longrightarrow> countable A \<Longrightarrow> range (from_nat_into A) = A"
   by (metis equalityI range_from_nat_into_subset subset_range_from_nat_into)
 
 lemma image_to_nat_on: "countable A \<Longrightarrow> infinite A \<Longrightarrow> to_nat_on A ` A = UNIV"
   using to_nat_on_infinite[of A] by (simp add: bij_betw_def)
 
 lemma to_nat_on_surj: "countable A \<Longrightarrow> infinite A \<Longrightarrow> \<exists>a\<in>A. to_nat_on A a = n"
   by (metis (no_types) image_iff iso_tuple_UNIV_I image_to_nat_on)
 
 lemma to_nat_on_from_nat_into[simp]: "n \<in> to_nat_on A ` A \<Longrightarrow> to_nat_on A (from_nat_into A n) = n"
   by (simp add: f_inv_into_f from_nat_into_def)
 
 lemma to_nat_on_from_nat_into_infinite[simp]:
   "countable A \<Longrightarrow> infinite A \<Longrightarrow> to_nat_on A (from_nat_into A n) = n"
   by (metis image_iff to_nat_on_surj to_nat_on_from_nat_into)
 
 lemma from_nat_into_inj:
   "countable A \<Longrightarrow> m \<in> to_nat_on A ` A \<Longrightarrow> n \<in> to_nat_on A ` A \<Longrightarrow>
     from_nat_into A m = from_nat_into A n \<longleftrightarrow> m = n"
   by (subst to_nat_on_inj[symmetric, of A]) auto
 
 lemma from_nat_into_inj_infinite[simp]:
   "countable A \<Longrightarrow> infinite A \<Longrightarrow> from_nat_into A m = from_nat_into A n \<longleftrightarrow> m = n"
   using image_to_nat_on[of A] from_nat_into_inj[of A m n] by simp
 
 lemma eq_from_nat_into_iff:
   "countable A \<Longrightarrow> x \<in> A \<Longrightarrow> i \<in> to_nat_on A ` A \<Longrightarrow> x = from_nat_into A i \<longleftrightarrow> i = to_nat_on A x"
   by auto
 
 lemma from_nat_into_surj: "countable A \<Longrightarrow> a \<in> A \<Longrightarrow> \<exists>n. from_nat_into A n = a"
   by (rule exI[of _ "to_nat_on A a"]) simp
 
 lemma from_nat_into_inject[simp]:
   "A \<noteq> {} \<Longrightarrow> countable A \<Longrightarrow> B \<noteq> {} \<Longrightarrow> countable B \<Longrightarrow> from_nat_into A = from_nat_into B \<longleftrightarrow> A = B"
   by (metis range_from_nat_into)
 
 lemma inj_on_from_nat_into: "inj_on from_nat_into ({A. A \<noteq> {} \<and> countable A})"
   unfolding inj_on_def by auto
 
 subsection \<open>Closure properties of countability\<close>
 
 lemma countable_SIGMA[intro, simp]:
   "countable I \<Longrightarrow> (\<And>i. i \<in> I \<Longrightarrow> countable (A i)) \<Longrightarrow> countable (SIGMA i : I. A i)"
   by (intro countableI'[of "\<lambda>(i, a). (to_nat_on I i, to_nat_on (A i) a)"]) (auto simp: inj_on_def)
 
 lemma countable_image[intro, simp]:
   assumes "countable A"
   shows "countable (f`A)"
 proof -
   obtain g :: "'a \<Rightarrow> nat" where "inj_on g A"
     using assms by (rule countableE)
   moreover have "inj_on (inv_into A f) (f`A)" "inv_into A f ` f ` A \<subseteq> A"
     by (auto intro: inj_on_inv_into inv_into_into)
   ultimately show ?thesis
     by (blast dest: comp_inj_on subset_inj_on intro: countableI)
 qed
 
 lemma countable_image_inj_on: "countable (f ` A) \<Longrightarrow> inj_on f A \<Longrightarrow> countable A"
   by (metis countable_image the_inv_into_onto)
 
 lemma countable_image_inj_Int_vimage:
    "\<lbrakk>inj_on f S; countable A\<rbrakk> \<Longrightarrow> countable (S \<inter> f -` A)"
   by (meson countable_image_inj_on countable_subset image_subset_iff_subset_vimage inf_le2 inj_on_Int)
 
 lemma countable_image_inj_gen:
    "\<lbrakk>inj_on f S; countable A\<rbrakk> \<Longrightarrow> countable {x \<in> S. f x \<in> A}"
   using countable_image_inj_Int_vimage
   by (auto simp: vimage_def Collect_conj_eq)
 
 lemma countable_image_inj_eq:
    "inj_on f S \<Longrightarrow> countable(f ` S) \<longleftrightarrow> countable S"
   using countable_image_inj_on by blast
 
 lemma countable_image_inj:
    "\<lbrakk>countable A; inj f\<rbrakk> \<Longrightarrow> countable {x. f x \<in> A}"
   by (metis (mono_tags, lifting) countable_image_inj_eq countable_subset image_Collect_subsetI inj_on_inverseI the_inv_f_f)
 
 lemma countable_UN[intro, simp]:
   fixes I :: "'i set" and A :: "'i => 'a set"
   assumes I: "countable I"
   assumes A: "\<And>i. i \<in> I \<Longrightarrow> countable (A i)"
   shows "countable (\<Union>i\<in>I. A i)"
 proof -
   have "(\<Union>i\<in>I. A i) = snd ` (SIGMA i : I. A i)" by (auto simp: image_iff)
   then show ?thesis by (simp add: assms)
 qed
 
 lemma countable_Un[intro]: "countable A \<Longrightarrow> countable B \<Longrightarrow> countable (A \<union> B)"
   by (rule countable_UN[of "{True, False}" "\<lambda>True \<Rightarrow> A | False \<Rightarrow> B", simplified])
      (simp split: bool.split)
 
 lemma countable_Un_iff[simp]: "countable (A \<union> B) \<longleftrightarrow> countable A \<and> countable B"
   by (metis countable_Un countable_subset inf_sup_ord(3,4))
 
 lemma countable_Plus[intro, simp]:
   "countable A \<Longrightarrow> countable B \<Longrightarrow> countable (A <+> B)"
   by (simp add: Plus_def)
 
 lemma countable_empty[intro, simp]: "countable {}"
   by (blast intro: countable_finite)
 
 lemma countable_insert[intro, simp]: "countable A \<Longrightarrow> countable (insert a A)"
   using countable_Un[of "{a}" A] by (auto simp: countable_finite)
 
 lemma countable_Int1[intro, simp]: "countable A \<Longrightarrow> countable (A \<inter> B)"
   by (force intro: countable_subset)
 
 lemma countable_Int2[intro, simp]: "countable B \<Longrightarrow> countable (A \<inter> B)"
   by (blast intro: countable_subset)
 
 lemma countable_INT[intro, simp]: "i \<in> I \<Longrightarrow> countable (A i) \<Longrightarrow> countable (\<Inter>i\<in>I. A i)"
   by (blast intro: countable_subset)
 
 lemma countable_Diff[intro, simp]: "countable A \<Longrightarrow> countable (A - B)"
   by (blast intro: countable_subset)
 
 lemma countable_insert_eq [simp]: "countable (insert x A) = countable A"
     by auto (metis Diff_insert_absorb countable_Diff insert_absorb)
 
 lemma countable_vimage: "B \<subseteq> range f \<Longrightarrow> countable (f -` B) \<Longrightarrow> countable B"
   by (metis Int_absorb2 countable_image image_vimage_eq)
 
 lemma surj_countable_vimage: "surj f \<Longrightarrow> countable (f -` B) \<Longrightarrow> countable B"
   by (metis countable_vimage top_greatest)
 
 lemma countable_Collect[simp]: "countable A \<Longrightarrow> countable {a \<in> A. \<phi> a}"
   by (metis Collect_conj_eq Int_absorb Int_commute Int_def countable_Int1)
 
 lemma countable_Image:
   assumes "\<And>y. y \<in> Y \<Longrightarrow> countable (X `` {y})"
   assumes "countable Y"
   shows "countable (X `` Y)"
 proof -
   have "countable (X `` (\<Union>y\<in>Y. {y}))"
     unfolding Image_UN by (intro countable_UN assms)
   then show ?thesis by simp
 qed
 
 lemma countable_relpow:
   fixes X :: "'a rel"
   assumes Image_X: "\<And>Y. countable Y \<Longrightarrow> countable (X `` Y)"
   assumes Y: "countable Y"
   shows "countable ((X ^^ i) `` Y)"
   using Y by (induct i arbitrary: Y) (auto simp: relcomp_Image Image_X)
 
 lemma countable_funpow:
   fixes f :: "'a set \<Rightarrow> 'a set"
   assumes "\<And>A. countable A \<Longrightarrow> countable (f A)"
   and "countable A"
   shows "countable ((f ^^ n) A)"
 by(induction n)(simp_all add: assms)
 
 lemma countable_rtrancl:
   "(\<And>Y. countable Y \<Longrightarrow> countable (X `` Y)) \<Longrightarrow> countable Y \<Longrightarrow> countable (X\<^sup>* `` Y)"
   unfolding rtrancl_is_UN_relpow UN_Image by (intro countable_UN countableI_type countable_relpow)
 
 lemma countable_lists[intro, simp]:
   assumes A: "countable A" shows "countable (lists A)"
 proof -
   have "countable (lists (range (from_nat_into A)))"
     by (auto simp: lists_image)
   with A show ?thesis
     by (auto dest: subset_range_from_nat_into countable_subset lists_mono)
 qed
 
 lemma Collect_finite_eq_lists: "Collect finite = set ` lists UNIV"
   using finite_list by auto
 
 lemma countable_Collect_finite: "countable (Collect (finite::'a::countable set\<Rightarrow>bool))"
   by (simp add: Collect_finite_eq_lists)
 
 lemma countable_int: "countable \<int>"
   unfolding Ints_def by auto
 
 lemma countable_rat: "countable \<rat>"
   unfolding Rats_def by auto
 
 lemma Collect_finite_subset_eq_lists: "{A. finite A \<and> A \<subseteq> T} = set ` lists T"
   using finite_list by (auto simp: lists_eq_set)
 
 lemma countable_Collect_finite_subset:
   "countable T \<Longrightarrow> countable {A. finite A \<and> A \<subseteq> T}"
   unfolding Collect_finite_subset_eq_lists by auto
 
 lemma countable_Fpow: "countable S \<Longrightarrow> countable (Fpow S)"
   using countable_Collect_finite_subset
   by (force simp add: Fpow_def conj_commute)
 
 lemma countable_set_option [simp]: "countable (set_option x)"
   by (cases x) auto
 
 subsection \<open>Misc lemmas\<close>
 
 lemma countable_subset_image:
    "countable B \<and> B \<subseteq> (f ` A) \<longleftrightarrow> (\<exists>A'. countable A' \<and> A' \<subseteq> A \<and> (B = f ` A'))"
    (is "?lhs = ?rhs")
 proof
   assume ?lhs
   show ?rhs
     by (rule exI [where x="inv_into A f ` B"])
       (use \<open>?lhs\<close> in \<open>auto simp: f_inv_into_f subset_iff image_inv_into_cancel inv_into_into\<close>)
 next
   assume ?rhs
   then show ?lhs by force
 qed
 
 lemma ex_subset_image_inj:
    "(\<exists>T. T \<subseteq> f ` S \<and> P T) \<longleftrightarrow> (\<exists>T. T \<subseteq> S \<and> inj_on f T \<and> P (f ` T))"
   by (auto simp: subset_image_inj)
 
 lemma all_subset_image_inj:
    "(\<forall>T. T \<subseteq> f ` S \<longrightarrow> P T) \<longleftrightarrow> (\<forall>T. T \<subseteq> S \<and> inj_on f T \<longrightarrow> P(f ` T))"
   by (metis subset_image_inj)
 
 lemma ex_countable_subset_image_inj:
    "(\<exists>T. countable T \<and> T \<subseteq> f ` S \<and> P T) \<longleftrightarrow>
     (\<exists>T. countable T \<and> T \<subseteq> S \<and> inj_on f T \<and> P (f ` T))"
   by (metis countable_image_inj_eq subset_image_inj)
 
 lemma all_countable_subset_image_inj:
    "(\<forall>T. countable T \<and> T \<subseteq> f ` S \<longrightarrow> P T) \<longleftrightarrow> (\<forall>T. countable T \<and> T \<subseteq> S \<and> inj_on f T \<longrightarrow>P(f ` T))"
   by (metis countable_image_inj_eq subset_image_inj)
 
 lemma ex_countable_subset_image:
    "(\<exists>T. countable T \<and> T \<subseteq> f ` S \<and> P T) \<longleftrightarrow> (\<exists>T. countable T \<and> T \<subseteq> S \<and> P (f ` T))"
   by (metis countable_subset_image)
 
 lemma all_countable_subset_image:
    "(\<forall>T. countable T \<and> T \<subseteq> f ` S \<longrightarrow> P T) \<longleftrightarrow> (\<forall>T. countable T \<and> T \<subseteq> S \<longrightarrow> P(f ` T))"
   by (metis countable_subset_image)
 
 lemma countable_image_eq:
    "countable(f ` S) \<longleftrightarrow> (\<exists>T. countable T \<and> T \<subseteq> S \<and> f ` S = f ` T)"
   by (metis countable_image countable_image_inj_eq order_refl subset_image_inj)
 
 lemma countable_image_eq_inj:
    "countable(f ` S) \<longleftrightarrow> (\<exists>T. countable T \<and> T \<subseteq> S \<and> f ` S = f ` T \<and> inj_on f T)"
   by (metis countable_image_inj_eq order_refl subset_image_inj)
 
 lemma infinite_countable_subset':
   assumes X: "infinite X" shows "\<exists>C\<subseteq>X. countable C \<and> infinite C"
 proof -
-  from infinite_countable_subset[OF X] guess f ..
+  obtain f :: "nat \<Rightarrow> 'a" where "inj f" "range f \<subseteq> X"
+    using infinite_countable_subset [OF X] by blast
   then show ?thesis
     by (intro exI[of _ "range f"]) (auto simp: range_inj_infinite)
 qed
 
 lemma countable_all:
   assumes S: "countable S"
   shows "(\<forall>s\<in>S. P s) \<longleftrightarrow> (\<forall>n::nat. from_nat_into S n \<in> S \<longrightarrow> P (from_nat_into S n))"
   using S[THEN subset_range_from_nat_into] by auto
 
 lemma finite_sequence_to_countable_set:
   assumes "countable X"
   obtains F where "\<And>i. F i \<subseteq> X" "\<And>i. F i \<subseteq> F (Suc i)" "\<And>i. finite (F i)" "(\<Union>i. F i) = X"
 proof -
   show thesis
     apply (rule that[of "\<lambda>i. if X = {} then {} else from_nat_into X ` {..i}"])
        apply (auto simp add: image_iff intro: from_nat_into split: if_splits)
     using assms from_nat_into_surj by (fastforce cong: image_cong)
 qed
 
 lemma transfer_countable[transfer_rule]:
   "bi_unique R \<Longrightarrow> rel_fun (rel_set R) (=) countable countable"
   by (rule rel_funI, erule (1) bi_unique_rel_set_lemma)
      (auto dest: countable_image_inj_on)
 
 subsection \<open>Uncountable\<close>
 
 abbreviation uncountable where
   "uncountable A \<equiv> \<not> countable A"
 
 lemma uncountable_def: "uncountable A \<longleftrightarrow> A \<noteq> {} \<and> \<not> (\<exists>f::(nat \<Rightarrow> 'a). range f = A)"
   by (auto intro: inj_on_inv_into simp: countable_def)
      (metis all_not_in_conv inj_on_iff_surj subset_UNIV)
 
 lemma uncountable_bij_betw: "bij_betw f A B \<Longrightarrow> uncountable B \<Longrightarrow> uncountable A"
   unfolding bij_betw_def by (metis countable_image)
 
 lemma uncountable_infinite: "uncountable A \<Longrightarrow> infinite A"
   by (metis countable_finite)
 
 lemma uncountable_minus_countable:
   "uncountable A \<Longrightarrow> countable B \<Longrightarrow> uncountable (A - B)"
   using countable_Un[of B "A - B"] by auto
 
 lemma countable_Diff_eq [simp]: "countable (A - {x}) = countable A"
   by (meson countable_Diff countable_empty countable_insert uncountable_minus_countable)
 
 text \<open>Every infinite set can be covered by a pairwise disjoint family of infinite sets.
       This version doesn't achieve equality, as it only covers a countable subset\<close>
 lemma infinite_infinite_partition:
   assumes "infinite A"
   obtains C :: "nat \<Rightarrow> 'a set" 
     where "pairwise (\<lambda>i j. disjnt (C i) (C j)) UNIV" "(\<Union>i. C i) \<subseteq> A" "\<And>i. infinite (C i)"
 proof -
   obtain f :: "nat\<Rightarrow>'a" where "range f \<subseteq> A" "inj f"
     using assms infinite_countable_subset by blast
   let ?C = "\<lambda>i. range (\<lambda>j. f (prod_encode (i,j)))"
   show thesis
   proof
     show "pairwise (\<lambda>i j. disjnt (?C i) (?C j)) UNIV"
       by (auto simp: pairwise_def disjnt_def inj_on_eq_iff [OF \<open>inj f\<close>] inj_on_eq_iff [OF inj_prod_encode, of _ UNIV])
     show "(\<Union>i. ?C i) \<subseteq> A"
       using \<open>range f \<subseteq> A\<close> by blast
     have "infinite (range (\<lambda>j. f (prod_encode (i, j))))" for i
       by (rule range_inj_infinite) (meson Pair_inject \<open>inj f\<close> inj_def prod_encode_eq)
     then show "\<And>i. infinite (?C i)"
       using that by auto
   qed
 qed
 
 end
diff --git a/src/HOL/Library/Extended_Nonnegative_Real.thy b/src/HOL/Library/Extended_Nonnegative_Real.thy
--- a/src/HOL/Library/Extended_Nonnegative_Real.thy
+++ b/src/HOL/Library/Extended_Nonnegative_Real.thy
@@ -1,2014 +1,2019 @@
 (*  Title:      HOL/Library/Extended_Nonnegative_Real.thy
     Author:     Johannes Hölzl
 *)
 
 subsection \<open>The type of non-negative extended real numbers\<close>
 
 theory Extended_Nonnegative_Real
   imports Extended_Real Indicator_Function
 begin
 
 lemma ereal_ineq_diff_add:
   assumes "b \<noteq> (-\<infinity>::ereal)" "a \<ge> b"
   shows "a = b + (a-b)"
 by (metis add.commute assms ereal_eq_minus_iff ereal_minus_le_iff ereal_plus_eq_PInfty)
 
 lemma Limsup_const_add:
   fixes c :: "'a::{complete_linorder, linorder_topology, topological_monoid_add, ordered_ab_semigroup_add}"
   shows "F \<noteq> bot \<Longrightarrow> Limsup F (\<lambda>x. c + f x) = c + Limsup F f"
   by (rule Limsup_compose_continuous_mono)
      (auto intro!: monoI add_mono continuous_on_add continuous_on_id continuous_on_const)
 
 lemma Liminf_const_add:
   fixes c :: "'a::{complete_linorder, linorder_topology, topological_monoid_add, ordered_ab_semigroup_add}"
   shows "F \<noteq> bot \<Longrightarrow> Liminf F (\<lambda>x. c + f x) = c + Liminf F f"
   by (rule Liminf_compose_continuous_mono)
      (auto intro!: monoI add_mono continuous_on_add continuous_on_id continuous_on_const)
 
 lemma Liminf_add_const:
   fixes c :: "'a::{complete_linorder, linorder_topology, topological_monoid_add, ordered_ab_semigroup_add}"
   shows "F \<noteq> bot \<Longrightarrow> Liminf F (\<lambda>x. f x + c) = Liminf F f + c"
   by (rule Liminf_compose_continuous_mono)
      (auto intro!: monoI add_mono continuous_on_add continuous_on_id continuous_on_const)
 
 lemma sums_offset:
   fixes f g :: "nat \<Rightarrow> 'a :: {t2_space, topological_comm_monoid_add}"
   assumes "(\<lambda>n. f (n + i)) sums l" shows "f sums (l + (\<Sum>j<i. f j))"
 proof  -
   have "(\<lambda>k. (\<Sum>n<k. f (n + i)) + (\<Sum>j<i. f j)) \<longlonglongrightarrow> l + (\<Sum>j<i. f j)"
     using assms by (auto intro!: tendsto_add simp: sums_def)
   moreover
   { fix k :: nat
     have "(\<Sum>j<k + i. f j) = (\<Sum>j=i..<k + i. f j) + (\<Sum>j=0..<i. f j)"
       by (subst sum.union_disjoint[symmetric]) (auto intro!: sum.cong)
     also have "(\<Sum>j=i..<k + i. f j) = (\<Sum>j\<in>(\<lambda>n. n + i)`{0..<k}. f j)"
       unfolding image_add_atLeastLessThan by simp
     finally have "(\<Sum>j<k + i. f j) = (\<Sum>n<k. f (n + i)) + (\<Sum>j<i. f j)"
       by (auto simp: inj_on_def atLeast0LessThan sum.reindex) }
   ultimately have "(\<lambda>k. (\<Sum>n<k + i. f n)) \<longlonglongrightarrow> l + (\<Sum>j<i. f j)"
     by simp
   then show ?thesis
     unfolding sums_def by (rule LIMSEQ_offset)
 qed
 
 lemma suminf_offset:
   fixes f g :: "nat \<Rightarrow> 'a :: {t2_space, topological_comm_monoid_add}"
   shows "summable (\<lambda>j. f (j + i)) \<Longrightarrow> suminf f = (\<Sum>j. f (j + i)) + (\<Sum>j<i. f j)"
   by (intro sums_unique[symmetric] sums_offset summable_sums)
 
 lemma eventually_at_left_1: "(\<And>z::real. 0 < z \<Longrightarrow> z < 1 \<Longrightarrow> P z) \<Longrightarrow> eventually P (at_left 1)"
   by (subst eventually_at_left[of 0]) (auto intro: exI[of _ 0])
 
 lemma mult_eq_1:
   fixes a b :: "'a :: {ordered_semiring, comm_monoid_mult}"
   shows "0 \<le> a \<Longrightarrow> a \<le> 1 \<Longrightarrow> b \<le> 1 \<Longrightarrow> a * b = 1 \<longleftrightarrow> (a = 1 \<and> b = 1)"
   by (metis mult.left_neutral eq_iff mult.commute mult_right_mono)
 
 lemma ereal_add_diff_cancel:
   fixes a b :: ereal
   shows "\<bar>b\<bar> \<noteq> \<infinity> \<Longrightarrow> (a + b) - b = a"
   by (cases a b rule: ereal2_cases) auto
 
 lemma add_top:
   fixes x :: "'a::{order_top, ordered_comm_monoid_add}"
   shows "0 \<le> x \<Longrightarrow> x + top = top"
   by (intro top_le add_increasing order_refl)
 
 lemma top_add:
   fixes x :: "'a::{order_top, ordered_comm_monoid_add}"
   shows "0 \<le> x \<Longrightarrow> top + x = top"
   by (intro top_le add_increasing2 order_refl)
 
 lemma le_lfp: "mono f \<Longrightarrow> x \<le> lfp f \<Longrightarrow> f x \<le> lfp f"
   by (subst lfp_unfold) (auto dest: monoD)
 
 lemma lfp_transfer:
   assumes \<alpha>: "sup_continuous \<alpha>" and f: "sup_continuous f" and mg: "mono g"
   assumes bot: "\<alpha> bot \<le> lfp g" and eq: "\<And>x. x \<le> lfp f \<Longrightarrow> \<alpha> (f x) = g (\<alpha> x)"
   shows "\<alpha> (lfp f) = lfp g"
 proof (rule antisym)
   note mf = sup_continuous_mono[OF f]
   have f_le_lfp: "(f ^^ i) bot \<le> lfp f" for i
     by (induction i) (auto intro: le_lfp mf)
 
   have "\<alpha> ((f ^^ i) bot) \<le> lfp g" for i
     by (induction i) (auto simp: bot eq f_le_lfp intro!: le_lfp mg)
   then show "\<alpha> (lfp f) \<le> lfp g"
     unfolding sup_continuous_lfp[OF f]
     by (subst \<alpha>[THEN sup_continuousD])
        (auto intro!: mono_funpow sup_continuous_mono[OF f] SUP_least)
 
   show "lfp g \<le> \<alpha> (lfp f)"
     by (rule lfp_lowerbound) (simp add: eq[symmetric] lfp_fixpoint[OF mf])
 qed
 
 lemma sup_continuous_applyD: "sup_continuous f \<Longrightarrow> sup_continuous (\<lambda>x. f x h)"
   using sup_continuous_apply[THEN sup_continuous_compose] .
 
 lemma sup_continuous_SUP[order_continuous_intros]:
   fixes M :: "_ \<Rightarrow> _ \<Rightarrow> 'a::complete_lattice"
   assumes M: "\<And>i. i \<in> I \<Longrightarrow> sup_continuous (M i)"
   shows  "sup_continuous (SUP i\<in>I. M i)"
   unfolding sup_continuous_def by (auto simp add: sup_continuousD [OF M] image_comp intro: SUP_commute)
 
 lemma sup_continuous_apply_SUP[order_continuous_intros]:
   fixes M :: "_ \<Rightarrow> _ \<Rightarrow> 'a::complete_lattice"
   shows "(\<And>i. i \<in> I \<Longrightarrow> sup_continuous (M i)) \<Longrightarrow> sup_continuous (\<lambda>x. SUP i\<in>I. M i x)"
   unfolding SUP_apply[symmetric] by (rule sup_continuous_SUP)
 
 lemma sup_continuous_lfp'[order_continuous_intros]:
   assumes 1: "sup_continuous f"
   assumes 2: "\<And>g. sup_continuous g \<Longrightarrow> sup_continuous (f g)"
   shows "sup_continuous (lfp f)"
 proof -
   have "sup_continuous ((f ^^ i) bot)" for i
   proof (induction i)
     case (Suc i) then show ?case
       by (auto intro!: 2)
   qed (simp add: bot_fun_def sup_continuous_const)
   then show ?thesis
     unfolding sup_continuous_lfp[OF 1] by (intro order_continuous_intros)
 qed
 
 lemma sup_continuous_lfp''[order_continuous_intros]:
   assumes 1: "\<And>s. sup_continuous (f s)"
   assumes 2: "\<And>g. sup_continuous g \<Longrightarrow> sup_continuous (\<lambda>s. f s (g s))"
   shows "sup_continuous (\<lambda>x. lfp (f x))"
 proof -
   have "sup_continuous (\<lambda>x. (f x ^^ i) bot)" for i
   proof (induction i)
     case (Suc i) then show ?case
       by (auto intro!: 2)
   qed (simp add: bot_fun_def sup_continuous_const)
   then show ?thesis
     unfolding sup_continuous_lfp[OF 1] by (intro order_continuous_intros)
 qed
 
 lemma mono_INF_fun:
     "(\<And>x y. mono (F x y)) \<Longrightarrow> mono (\<lambda>z x. INF y \<in> X x. F x y z :: 'a :: complete_lattice)"
   by (auto intro!: INF_mono[OF bexI] simp: le_fun_def mono_def)
 
 lemma continuous_on_cmult_ereal:
   "\<bar>c::ereal\<bar> \<noteq> \<infinity> \<Longrightarrow> continuous_on A f \<Longrightarrow> continuous_on A (\<lambda>x. c * f x)"
   using tendsto_cmult_ereal[of c f "f x" "at x within A" for x]
   by (auto simp: continuous_on_def simp del: tendsto_cmult_ereal)
 
 lemma real_of_nat_Sup:
   assumes "A \<noteq> {}" "bdd_above A"
   shows "of_nat (Sup A) = (SUP a\<in>A. of_nat a :: real)"
 proof (intro antisym)
   show "(SUP a\<in>A. of_nat a::real) \<le> of_nat (Sup A)"
     using assms by (intro cSUP_least of_nat_mono) (auto intro: cSup_upper)
   have "Sup A \<in> A"
     using assms by (auto simp: Sup_nat_def bdd_above_nat)
   then show "of_nat (Sup A) \<le> (SUP a\<in>A. of_nat a::real)"
     by (intro cSUP_upper bdd_above_image_mono assms) (auto simp: mono_def)
 qed
 
 lemma (in complete_lattice) SUP_sup_const1:
   "I \<noteq> {} \<Longrightarrow> (SUP i\<in>I. sup c (f i)) = sup c (SUP i\<in>I. f i)"
   using SUP_sup_distrib[of "\<lambda>_. c" I f] by simp
 
 lemma (in complete_lattice) SUP_sup_const2:
   "I \<noteq> {} \<Longrightarrow> (SUP i\<in>I. sup (f i) c) = sup (SUP i\<in>I. f i) c"
   using SUP_sup_distrib[of f I "\<lambda>_. c"] by simp
 
 lemma one_less_of_natD:
   assumes "(1::'a::linordered_semidom) < of_nat n" shows "1 < n"
   by (cases n) (use assms in auto)
 
 subsection \<open>Defining the extended non-negative reals\<close>
 
 text \<open>Basic definitions and type class setup\<close>
 
 typedef ennreal = "{x :: ereal. 0 \<le> x}"
   morphisms enn2ereal e2ennreal'
   by auto
 
 definition "e2ennreal x = e2ennreal' (max 0 x)"
 
 lemma enn2ereal_range: "e2ennreal ` {0..} = UNIV"
 proof -
   have "\<exists>y\<ge>0. x = e2ennreal y" for x
     by (cases x) (auto simp: e2ennreal_def max_absorb2)
   then show ?thesis
     by (auto simp: image_iff Bex_def)
 qed
 
 lemma type_definition_ennreal': "type_definition enn2ereal e2ennreal {x. 0 \<le> x}"
   using type_definition_ennreal
   by (auto simp: type_definition_def e2ennreal_def max_absorb2)
 
 setup_lifting type_definition_ennreal'
 
 declare [[coercion e2ennreal]]
 
 instantiation ennreal :: complete_linorder
 begin
 
 lift_definition top_ennreal :: ennreal is top by (rule top_greatest)
 lift_definition bot_ennreal :: ennreal is 0 by (rule order_refl)
 lift_definition sup_ennreal :: "ennreal \<Rightarrow> ennreal \<Rightarrow> ennreal" is sup by (rule le_supI1)
 lift_definition inf_ennreal :: "ennreal \<Rightarrow> ennreal \<Rightarrow> ennreal" is inf by (rule le_infI)
 
 lift_definition Inf_ennreal :: "ennreal set \<Rightarrow> ennreal" is "Inf"
   by (rule Inf_greatest)
 
 lift_definition Sup_ennreal :: "ennreal set \<Rightarrow> ennreal" is "sup 0 \<circ> Sup"
   by auto
 
 lift_definition less_eq_ennreal :: "ennreal \<Rightarrow> ennreal \<Rightarrow> bool" is "(\<le>)" .
 lift_definition less_ennreal :: "ennreal \<Rightarrow> ennreal \<Rightarrow> bool" is "(<)" .
 
 instance
   by standard
      (transfer ; auto simp: Inf_lower Inf_greatest Sup_upper Sup_least le_max_iff_disj max.absorb1)+
 
 end
 
 lemma pcr_ennreal_enn2ereal[simp]: "pcr_ennreal (enn2ereal x) x"
   by (simp add: ennreal.pcr_cr_eq cr_ennreal_def)
 
 lemma rel_fun_eq_pcr_ennreal: "rel_fun (=) pcr_ennreal f g \<longleftrightarrow> f = enn2ereal \<circ> g"
   by (auto simp: rel_fun_def ennreal.pcr_cr_eq cr_ennreal_def)
 
 instantiation ennreal :: infinity
 begin
 
 definition infinity_ennreal :: ennreal
 where
   [simp]: "\<infinity> = (top::ennreal)"
 
 instance ..
 
 end
 
 instantiation ennreal :: "{semiring_1_no_zero_divisors, comm_semiring_1}"
 begin
 
 lift_definition one_ennreal :: ennreal is 1 by simp
 lift_definition zero_ennreal :: ennreal is 0 by simp
 lift_definition plus_ennreal :: "ennreal \<Rightarrow> ennreal \<Rightarrow> ennreal" is "(+)" by simp
 lift_definition times_ennreal :: "ennreal \<Rightarrow> ennreal \<Rightarrow> ennreal" is "(*)" by simp
 
 instance
   by standard (transfer; auto simp: field_simps ereal_right_distrib)+
 
 end
 
 instantiation ennreal :: minus
 begin
 
 lift_definition minus_ennreal :: "ennreal \<Rightarrow> ennreal \<Rightarrow> ennreal" is "\<lambda>a b. max 0 (a - b)"
   by simp
 
 instance ..
 
 end
 
 instance ennreal :: numeral ..
 
 instantiation ennreal :: inverse
 begin
 
 lift_definition inverse_ennreal :: "ennreal \<Rightarrow> ennreal" is inverse
   by (rule inverse_ereal_ge0I)
 
 definition divide_ennreal :: "ennreal \<Rightarrow> ennreal \<Rightarrow> ennreal"
   where "x div y = x * inverse (y :: ennreal)"
 
 instance ..
 
 end
 
 lemma ennreal_zero_less_one: "0 < (1::ennreal)" \<comment> \<open>TODO: remove\<close>
   by transfer auto
 
 instance ennreal :: dioid
 proof (standard; transfer)
   fix a b :: ereal assume "0 \<le> a" "0 \<le> b" then show "(a \<le> b) = (\<exists>c\<in>Collect ((\<le>) 0). b = a + c)"
     unfolding ereal_ex_split Bex_def
     by (cases a b rule: ereal2_cases) (auto intro!: exI[of _ "real_of_ereal (b - a)"])
 qed
 
 instance ennreal :: ordered_comm_semiring
   by standard
      (transfer ; auto intro: add_mono mult_mono mult_ac ereal_left_distrib ereal_mult_left_mono)+
 
 instance ennreal :: linordered_nonzero_semiring
 proof
   fix a b::ennreal
   show "a < b \<Longrightarrow> a + 1 < b + 1"
     by transfer (simp add: add_right_mono ereal_add_cancel_right less_le)
 qed (transfer; simp)
 
 instance ennreal :: strict_ordered_ab_semigroup_add
 proof
   fix a b c d :: ennreal show "a < b \<Longrightarrow> c < d \<Longrightarrow> a + c < b + d"
     by transfer (auto intro!: ereal_add_strict_mono)
 qed
 
 declare [[coercion "of_nat :: nat \<Rightarrow> ennreal"]]
 
 lemma e2ennreal_neg: "x \<le> 0 \<Longrightarrow> e2ennreal x = 0"
   unfolding zero_ennreal_def e2ennreal_def by (simp add: max_absorb1)
 
 lemma e2ennreal_mono: "x \<le> y \<Longrightarrow> e2ennreal x \<le> e2ennreal y"
   by (cases "0 \<le> x" "0 \<le> y" rule: bool.exhaust[case_product bool.exhaust])
      (auto simp: e2ennreal_neg less_eq_ennreal.abs_eq eq_onp_def)
 
 lemma enn2ereal_nonneg[simp]: "0 \<le> enn2ereal x"
   using ennreal.enn2ereal[of x] by simp
 
 lemma ereal_ennreal_cases:
   obtains b where "0 \<le> a" "a = enn2ereal b" | "a < 0"
   using e2ennreal'_inverse[of a, symmetric] by (cases "0 \<le> a") (auto intro: enn2ereal_nonneg)
 
 lemma rel_fun_liminf[transfer_rule]: "rel_fun (rel_fun (=) pcr_ennreal) pcr_ennreal liminf liminf"
 proof -
   have "rel_fun (rel_fun (=) pcr_ennreal) pcr_ennreal (\<lambda>x. sup 0 (liminf x)) liminf"
     unfolding liminf_SUP_INF[abs_def] by (transfer_prover_start, transfer_step+; simp)
   then show ?thesis
     apply (subst (asm) (2) rel_fun_def)
     apply (subst (2) rel_fun_def)
     apply (auto simp: comp_def max.absorb2 Liminf_bounded rel_fun_eq_pcr_ennreal)
     done
 qed
 
 lemma rel_fun_limsup[transfer_rule]: "rel_fun (rel_fun (=) pcr_ennreal) pcr_ennreal limsup limsup"
 proof -
   have "rel_fun (rel_fun (=) pcr_ennreal) pcr_ennreal (\<lambda>x. INF n. sup 0 (SUP i\<in>{n..}. x i)) limsup"
     unfolding limsup_INF_SUP[abs_def] by (transfer_prover_start, transfer_step+; simp)
   then show ?thesis
     unfolding limsup_INF_SUP[abs_def]
     apply (subst (asm) (2) rel_fun_def)
     apply (subst (2) rel_fun_def)
     apply (auto simp: comp_def max.absorb2 Sup_upper2 rel_fun_eq_pcr_ennreal)
     apply (subst (asm) max.absorb2)
     apply (auto intro: SUP_upper2)
     done
 qed
 
 lemma sum_enn2ereal[simp]: "(\<And>i. i \<in> I \<Longrightarrow> 0 \<le> f i) \<Longrightarrow> (\<Sum>i\<in>I. enn2ereal (f i)) = enn2ereal (sum f I)"
   by (induction I rule: infinite_finite_induct) (auto simp: sum_nonneg zero_ennreal.rep_eq plus_ennreal.rep_eq)
 
 lemma transfer_e2ennreal_sum [transfer_rule]:
   "rel_fun (rel_fun (=) pcr_ennreal) (rel_fun (=) pcr_ennreal) sum sum"
   by (auto intro!: rel_funI simp: rel_fun_eq_pcr_ennreal comp_def)
 
 lemma enn2ereal_of_nat[simp]: "enn2ereal (of_nat n) = ereal n"
   by (induction n) (auto simp: zero_ennreal.rep_eq one_ennreal.rep_eq plus_ennreal.rep_eq)
 
 lemma enn2ereal_numeral[simp]: "enn2ereal (numeral a) = numeral a"
   by (metis enn2ereal_of_nat numeral_eq_ereal of_nat_numeral)
 
 lemma transfer_numeral[transfer_rule]: "pcr_ennreal (numeral a) (numeral a)"
   unfolding cr_ennreal_def pcr_ennreal_def by auto
 
 subsection \<open>Cancellation simprocs\<close>
 
 lemma ennreal_add_left_cancel: "a + b = a + c \<longleftrightarrow> a = (\<infinity>::ennreal) \<or> b = c"
   unfolding infinity_ennreal_def by transfer (simp add: top_ereal_def ereal_add_cancel_left)
 
 lemma ennreal_add_left_cancel_le: "a + b \<le> a + c \<longleftrightarrow> a = (\<infinity>::ennreal) \<or> b \<le> c"
   unfolding infinity_ennreal_def by transfer (simp add: ereal_add_le_add_iff top_ereal_def disj_commute)
 
 lemma ereal_add_left_cancel_less:
   fixes a b c :: ereal
   shows "0 \<le> a \<Longrightarrow> 0 \<le> b \<Longrightarrow> a + b < a + c \<longleftrightarrow> a \<noteq> \<infinity> \<and> b < c"
   by (cases a b c rule: ereal3_cases) auto
 
 lemma ennreal_add_left_cancel_less: "a + b < a + c \<longleftrightarrow> a \<noteq> (\<infinity>::ennreal) \<and> b < c"
   unfolding infinity_ennreal_def
   by transfer (simp add: top_ereal_def ereal_add_left_cancel_less)
 
 ML \<open>
 structure Cancel_Ennreal_Common =
 struct
   (* copied from src/HOL/Tools/nat_numeral_simprocs.ML *)
   fun find_first_t _    _ []         = raise TERM("find_first_t", [])
     | find_first_t past u (t::terms) =
           if u aconv t then (rev past @ terms)
           else find_first_t (t::past) u terms
 
   fun dest_summing (Const (\<^const_name>\<open>Groups.plus\<close>, _) $ t $ u, ts) =
         dest_summing (t, dest_summing (u, ts))
     | dest_summing (t, ts) = t :: ts
 
   val mk_sum = Arith_Data.long_mk_sum
   fun dest_sum t = dest_summing (t, [])
   val find_first = find_first_t []
   val trans_tac = Numeral_Simprocs.trans_tac
   val norm_ss =
     simpset_of (put_simpset HOL_basic_ss \<^context>
       addsimps @{thms ac_simps add_0_left add_0_right})
   fun norm_tac ctxt = ALLGOALS (simp_tac (put_simpset norm_ss ctxt))
   fun simplify_meta_eq ctxt cancel_th th =
     Arith_Data.simplify_meta_eq [] ctxt
       ([th, cancel_th] MRS trans)
   fun mk_eq (a, b) = HOLogic.mk_Trueprop (HOLogic.mk_eq (a, b))
 end
 
 structure Eq_Ennreal_Cancel = ExtractCommonTermFun
 (open Cancel_Ennreal_Common
   val mk_bal = HOLogic.mk_eq
   val dest_bal = HOLogic.dest_bin \<^const_name>\<open>HOL.eq\<close> \<^typ>\<open>ennreal\<close>
   fun simp_conv _ _ = SOME @{thm ennreal_add_left_cancel}
 )
 
 structure Le_Ennreal_Cancel = ExtractCommonTermFun
 (open Cancel_Ennreal_Common
   val mk_bal = HOLogic.mk_binrel \<^const_name>\<open>Orderings.less_eq\<close>
   val dest_bal = HOLogic.dest_bin \<^const_name>\<open>Orderings.less_eq\<close> \<^typ>\<open>ennreal\<close>
   fun simp_conv _ _ = SOME @{thm ennreal_add_left_cancel_le}
 )
 
 structure Less_Ennreal_Cancel = ExtractCommonTermFun
 (open Cancel_Ennreal_Common
   val mk_bal = HOLogic.mk_binrel \<^const_name>\<open>Orderings.less\<close>
   val dest_bal = HOLogic.dest_bin \<^const_name>\<open>Orderings.less\<close> \<^typ>\<open>ennreal\<close>
   fun simp_conv _ _ = SOME @{thm ennreal_add_left_cancel_less}
 )
 \<close>
 
 simproc_setup ennreal_eq_cancel
   ("(l::ennreal) + m = n" | "(l::ennreal) = m + n") =
   \<open>fn phi => fn ctxt => fn ct => Eq_Ennreal_Cancel.proc ctxt (Thm.term_of ct)\<close>
 
 simproc_setup ennreal_le_cancel
   ("(l::ennreal) + m \<le> n" | "(l::ennreal) \<le> m + n") =
   \<open>fn phi => fn ctxt => fn ct => Le_Ennreal_Cancel.proc ctxt (Thm.term_of ct)\<close>
 
 simproc_setup ennreal_less_cancel
   ("(l::ennreal) + m < n" | "(l::ennreal) < m + n") =
   \<open>fn phi => fn ctxt => fn ct => Less_Ennreal_Cancel.proc ctxt (Thm.term_of ct)\<close>
 
 
 subsection \<open>Order with top\<close>
 
 lemma ennreal_zero_less_top[simp]: "0 < (top::ennreal)"
   by transfer (simp add: top_ereal_def)
 
 lemma ennreal_one_less_top[simp]: "1 < (top::ennreal)"
   by transfer (simp add: top_ereal_def)
 
 lemma ennreal_zero_neq_top[simp]: "0 \<noteq> (top::ennreal)"
   by transfer (simp add: top_ereal_def)
 
 lemma ennreal_top_neq_zero[simp]: "(top::ennreal) \<noteq> 0"
   by transfer (simp add: top_ereal_def)
 
 lemma ennreal_top_neq_one[simp]: "top \<noteq> (1::ennreal)"
   by transfer (simp add: top_ereal_def one_ereal_def flip: ereal_max)
 
 lemma ennreal_one_neq_top[simp]: "1 \<noteq> (top::ennreal)"
   by transfer (simp add: top_ereal_def one_ereal_def flip: ereal_max)
 
 lemma ennreal_add_less_top[simp]:
   fixes a b :: ennreal
   shows "a + b < top \<longleftrightarrow> a < top \<and> b < top"
   by transfer (auto simp: top_ereal_def)
 
 lemma ennreal_add_eq_top[simp]:
   fixes a b :: ennreal
   shows "a + b = top \<longleftrightarrow> a = top \<or> b = top"
   by transfer (auto simp: top_ereal_def)
 
 lemma ennreal_sum_less_top[simp]:
   fixes f :: "'a \<Rightarrow> ennreal"
   shows "finite I \<Longrightarrow> (\<Sum>i\<in>I. f i) < top \<longleftrightarrow> (\<forall>i\<in>I. f i < top)"
   by (induction I rule: finite_induct) auto
 
 lemma ennreal_sum_eq_top[simp]:
   fixes f :: "'a \<Rightarrow> ennreal"
   shows "finite I \<Longrightarrow> (\<Sum>i\<in>I. f i) = top \<longleftrightarrow> (\<exists>i\<in>I. f i = top)"
   by (induction I rule: finite_induct) auto
 
 lemma ennreal_mult_eq_top_iff:
   fixes a b :: ennreal
   shows "a * b = top \<longleftrightarrow> (a = top \<and> b \<noteq> 0) \<or> (b = top \<and> a \<noteq> 0)"
   by transfer (auto simp: top_ereal_def)
 
 lemma ennreal_top_eq_mult_iff:
   fixes a b :: ennreal
   shows "top = a * b \<longleftrightarrow> (a = top \<and> b \<noteq> 0) \<or> (b = top \<and> a \<noteq> 0)"
   using ennreal_mult_eq_top_iff[of a b] by auto
 
 lemma ennreal_mult_less_top:
   fixes a b :: ennreal
   shows "a * b < top \<longleftrightarrow> (a = 0 \<or> b = 0 \<or> (a < top \<and> b < top))"
   by transfer (auto simp add: top_ereal_def)
 
 lemma top_power_ennreal: "top ^ n = (if n = 0 then 1 else top :: ennreal)"
   by (induction n) (simp_all add: ennreal_mult_eq_top_iff)
 
 lemma ennreal_prod_eq_0[simp]:
   fixes f :: "'a \<Rightarrow> ennreal"
   shows "(prod f A = 0) = (finite A \<and> (\<exists>i\<in>A. f i = 0))"
   by (induction A rule: infinite_finite_induct) auto
 
 lemma ennreal_prod_eq_top:
   fixes f :: "'a \<Rightarrow> ennreal"
   shows "(\<Prod>i\<in>I. f i) = top \<longleftrightarrow> (finite I \<and> ((\<forall>i\<in>I. f i \<noteq> 0) \<and> (\<exists>i\<in>I. f i = top)))"
   by (induction I rule: infinite_finite_induct) (auto simp: ennreal_mult_eq_top_iff)
 
 lemma ennreal_top_mult: "top * a = (if a = 0 then 0 else top :: ennreal)"
   by (simp add: ennreal_mult_eq_top_iff)
 
 lemma ennreal_mult_top: "a * top = (if a = 0 then 0 else top :: ennreal)"
   by (simp add: ennreal_mult_eq_top_iff)
 
 lemma enn2ereal_eq_top_iff[simp]: "enn2ereal x = \<infinity> \<longleftrightarrow> x = top"
   by transfer (simp add: top_ereal_def)
 
 lemma enn2ereal_top[simp]: "enn2ereal top = \<infinity>"
   by transfer (simp add: top_ereal_def)
 
 lemma e2ennreal_infty[simp]: "e2ennreal \<infinity> = top"
   by (simp add: top_ennreal.abs_eq top_ereal_def)
 
 lemma ennreal_top_minus[simp]: "top - x = (top::ennreal)"
   by transfer (auto simp: top_ereal_def max_def)
 
 lemma minus_top_ennreal: "x - top = (if x = top then top else 0:: ennreal)"
   by transfer (use ereal_eq_minus_iff top_ereal_def in force)
 
 lemma bot_ennreal: "bot = (0::ennreal)"
   by transfer rule
 
 lemma ennreal_of_nat_neq_top[simp]: "of_nat i \<noteq> (top::ennreal)"
   by (induction i) auto
 
 lemma numeral_eq_of_nat: "(numeral a::ennreal) = of_nat (numeral a)"
   by simp
 
 lemma of_nat_less_top: "of_nat i < (top::ennreal)"
   using less_le_trans[of "of_nat i" "of_nat (Suc i)" "top::ennreal"]
   by simp
 
 lemma top_neq_numeral[simp]: "top \<noteq> (numeral i::ennreal)"
   using of_nat_less_top[of "numeral i"] by simp
 
 lemma ennreal_numeral_less_top[simp]: "numeral i < (top::ennreal)"
   using of_nat_less_top[of "numeral i"] by simp
 
 lemma ennreal_add_bot[simp]: "bot + x = (x::ennreal)"
   by transfer simp
 
 lemma add_top_right_ennreal [simp]: "x + top = (top :: ennreal)"
   by (cases x) auto
 
 lemma add_top_left_ennreal [simp]: "top + x = (top :: ennreal)"
   by (cases x) auto
 
 lemma ennreal_top_mult_left [simp]: "x \<noteq> 0 \<Longrightarrow> x * top = (top :: ennreal)"
   by (subst ennreal_mult_eq_top_iff) auto
 
 lemma ennreal_top_mult_right [simp]: "x \<noteq> 0 \<Longrightarrow> top * x = (top :: ennreal)"
   by (subst ennreal_mult_eq_top_iff) auto
 
 
 lemma power_top_ennreal [simp]: "n > 0 \<Longrightarrow> top ^ n = (top :: ennreal)"
   by (induction n) auto
 
 lemma power_eq_top_ennreal_iff: "x ^ n = top \<longleftrightarrow> x = (top :: ennreal) \<and> n > 0"
   by (induction n) (auto simp: ennreal_mult_eq_top_iff)
 
 lemma ennreal_mult_le_mult_iff: "c \<noteq> 0 \<Longrightarrow> c \<noteq> top \<Longrightarrow> c * a \<le> c * b \<longleftrightarrow> a \<le> (b :: ennreal)"
   including ennreal.lifting
   by (transfer, subst ereal_mult_le_mult_iff) (auto simp: top_ereal_def)
 
 lemma power_mono_ennreal: "x \<le> y \<Longrightarrow> x ^ n \<le> (y ^ n :: ennreal)"
   by (induction n) (auto intro!: mult_mono)
 
 instance ennreal :: semiring_char_0
 proof (standard, safe intro!: linorder_injI)
   have *: "1 + of_nat k \<noteq> (0::ennreal)" for k
     using add_pos_nonneg[OF zero_less_one, of "of_nat k :: ennreal"] by auto
   fix x y :: nat assume "x < y" "of_nat x = (of_nat y::ennreal)" then show False
     by (auto simp add: less_iff_Suc_add *)
 qed
 
 subsection \<open>Arithmetic\<close>
 
 lemma ennreal_minus_zero[simp]: "a - (0::ennreal) = a"
   by transfer (auto simp: max_def)
 
 lemma ennreal_add_diff_cancel_right[simp]:
   fixes x y z :: ennreal shows "y \<noteq> top \<Longrightarrow> (x + y) - y = x"
   by transfer (metis ereal_eq_minus_iff max_absorb2 not_MInfty_nonneg top_ereal_def)
 
 lemma ennreal_add_diff_cancel_left[simp]:
   fixes x y z :: ennreal shows "y \<noteq> top \<Longrightarrow> (y + x) - y = x"
   by (simp add: add.commute)
 
 lemma
   fixes a b :: ennreal
   shows "a - b = 0 \<Longrightarrow> a \<le> b"
   by transfer (metis ereal_diff_gr0 le_cases max.absorb2 not_less)
 
 lemma ennreal_minus_cancel:
   fixes a b c :: ennreal
   shows "c \<noteq> top \<Longrightarrow> a \<le> c \<Longrightarrow> b \<le> c \<Longrightarrow> c - a = c - b \<Longrightarrow> a = b"
   apply transfer
   subgoal for a b c
     by (cases a b c rule: ereal3_cases)
        (auto simp: top_ereal_def max_def split: if_splits)
   done
 
 lemma sup_const_add_ennreal:
   fixes a b c :: "ennreal"
   shows "sup (c + a) (c + b) = c + sup a b"
   by transfer (metis add_left_mono le_cases sup.absorb2 sup.orderE)
 
 lemma ennreal_diff_add_assoc:
   fixes a b c :: ennreal
   shows "a \<le> b \<Longrightarrow> c + b - a = c + (b - a)"
   apply transfer
   subgoal for a b c
     by (cases a b c rule: ereal3_cases) (auto simp: field_simps max_absorb2)
   done
 
 lemma mult_divide_eq_ennreal:
   fixes a b :: ennreal
   shows "b \<noteq> 0 \<Longrightarrow> b \<noteq> top \<Longrightarrow> (a * b) / b = a"
   unfolding divide_ennreal_def
   apply transfer
   apply (subst mult.assoc)
   apply (simp add: top_ereal_def flip: divide_ereal_def)
   done
 
 lemma divide_mult_eq: "a \<noteq> 0 \<Longrightarrow> a \<noteq> \<infinity> \<Longrightarrow> x * a / (b * a) = x / (b::ennreal)"
   unfolding divide_ennreal_def infinity_ennreal_def
   apply transfer
   subgoal for a b c
     apply (cases a b c rule: ereal3_cases)
     apply (auto simp: top_ereal_def)
     done
   done
 
 lemma ennreal_mult_divide_eq:
   fixes a b :: ennreal
   shows "b \<noteq> 0 \<Longrightarrow> b \<noteq> top \<Longrightarrow> (a * b) / b = a"
   unfolding divide_ennreal_def
   apply transfer
   apply (subst mult.assoc)
   apply (simp add: top_ereal_def flip: divide_ereal_def)
   done
 
 lemma ennreal_add_diff_cancel:
   fixes a b :: ennreal
   shows "b \<noteq> \<infinity> \<Longrightarrow> (a + b) - b = a"
   unfolding infinity_ennreal_def
   by transfer (simp add: max_absorb2 top_ereal_def ereal_add_diff_cancel)
 
 lemma ennreal_minus_eq_0:
   "a - b = 0 \<Longrightarrow> a \<le> (b::ennreal)"
   by transfer (metis ereal_diff_gr0 le_cases max.absorb2 not_less)
 
 lemma ennreal_mono_minus_cancel:
   fixes a b c :: ennreal
   shows "a - b \<le> a - c \<Longrightarrow> a < top \<Longrightarrow> b \<le> a \<Longrightarrow> c \<le> a \<Longrightarrow> c \<le> b"
   by transfer
      (auto simp add: max.absorb2 ereal_diff_positive top_ereal_def dest: ereal_mono_minus_cancel)
 
 lemma ennreal_mono_minus:
   fixes a b c :: ennreal
   shows "c \<le> b \<Longrightarrow> a - b \<le> a - c"
   by transfer (meson ereal_minus_mono max.mono order_refl)
 
 lemma ennreal_minus_pos_iff:
   fixes a b :: ennreal
   shows "a < top \<or> b < top \<Longrightarrow> 0 < a - b \<Longrightarrow> b < a"
   by transfer (use add.left_neutral ereal_minus_le_iff less_irrefl not_less in fastforce)
 
 lemma ennreal_inverse_top[simp]: "inverse top = (0::ennreal)"
   by transfer (simp add: top_ereal_def ereal_inverse_eq_0)
 
 lemma ennreal_inverse_zero[simp]: "inverse 0 = (top::ennreal)"
   by transfer (simp add: top_ereal_def ereal_inverse_eq_0)
 
 lemma ennreal_top_divide: "top / (x::ennreal) = (if x = top then 0 else top)"
   unfolding divide_ennreal_def
   by transfer (simp add: top_ereal_def ereal_inverse_eq_0 ereal_0_gt_inverse)
 
 lemma ennreal_zero_divide[simp]: "0 / (x::ennreal) = 0"
   by (simp add: divide_ennreal_def)
 
 lemma ennreal_divide_zero[simp]: "x / (0::ennreal) = (if x = 0 then 0 else top)"
   by (simp add: divide_ennreal_def ennreal_mult_top)
 
 lemma ennreal_divide_top[simp]: "x / (top::ennreal) = 0"
   by (simp add: divide_ennreal_def ennreal_top_mult)
 
 lemma ennreal_times_divide: "a * (b / c) = a * b / (c::ennreal)"
   unfolding divide_ennreal_def
   by transfer (simp add: divide_ereal_def[symmetric] ereal_times_divide_eq)
 
 lemma ennreal_zero_less_divide: "0 < a / b \<longleftrightarrow> (0 < a \<and> b < (top::ennreal))"
   unfolding divide_ennreal_def
   by transfer (auto simp: ereal_zero_less_0_iff top_ereal_def ereal_0_gt_inverse)
 
 lemma add_divide_distrib_ennreal: "(a + b) / c = a / c + b / (c :: ennreal)"
   by (simp add: divide_ennreal_def ring_distribs)
 
 lemma divide_right_mono_ennreal:
   fixes a b c :: ennreal
   shows "a \<le> b \<Longrightarrow> a / c \<le> b / c"
   unfolding divide_ennreal_def by (intro mult_mono) auto
 
 lemma ennreal_mult_strict_right_mono: "(a::ennreal) < c \<Longrightarrow> 0 < b \<Longrightarrow> b < top \<Longrightarrow> a * b < c * b"
   by transfer (auto intro!: ereal_mult_strict_right_mono)
 
 lemma ennreal_indicator_less[simp]:
   "indicator A x \<le> (indicator B x::ennreal) \<longleftrightarrow> (x \<in> A \<longrightarrow> x \<in> B)"
   by (simp add: indicator_def not_le)
 
 lemma ennreal_inverse_positive: "0 < inverse x \<longleftrightarrow> (x::ennreal) \<noteq> top"
   by transfer (simp add: ereal_0_gt_inverse top_ereal_def)
 
 lemma ennreal_inverse_mult': "((0 < b \<or> a < top) \<and> (0 < a \<or> b < top)) \<Longrightarrow> inverse (a * b::ennreal) = inverse a * inverse b"
   apply transfer
   subgoal for a b
     by (cases a b rule: ereal2_cases) (auto simp: top_ereal_def)
   done
 
 lemma ennreal_inverse_mult: "a < top \<Longrightarrow> b < top \<Longrightarrow> inverse (a * b::ennreal) = inverse a * inverse b"
   apply transfer
   subgoal for a b
     by (cases a b rule: ereal2_cases) (auto simp: top_ereal_def)
   done
 
 lemma ennreal_inverse_1[simp]: "inverse (1::ennreal) = 1"
   by transfer simp
 
 lemma ennreal_inverse_eq_0_iff[simp]: "inverse (a::ennreal) = 0 \<longleftrightarrow> a = top"
   by transfer (simp add: ereal_inverse_eq_0 top_ereal_def)
 
 lemma ennreal_inverse_eq_top_iff[simp]: "inverse (a::ennreal) = top \<longleftrightarrow> a = 0"
   by transfer (simp add: top_ereal_def)
 
 lemma ennreal_divide_eq_0_iff[simp]: "(a::ennreal) / b = 0 \<longleftrightarrow> (a = 0 \<or> b = top)"
   by (simp add: divide_ennreal_def)
 
 lemma ennreal_divide_eq_top_iff: "(a::ennreal) / b = top \<longleftrightarrow> ((a \<noteq> 0 \<and> b = 0) \<or> (a = top \<and> b \<noteq> top))"
   by (auto simp add: divide_ennreal_def ennreal_mult_eq_top_iff)
 
 lemma one_divide_one_divide_ennreal[simp]: "1 / (1 / c) = (c::ennreal)"
   including ennreal.lifting
   unfolding divide_ennreal_def
   by transfer auto
 
 lemma ennreal_mult_left_cong:
   "((a::ennreal) \<noteq> 0 \<Longrightarrow> b = c) \<Longrightarrow> a * b = a * c"
   by (cases "a = 0") simp_all
 
 lemma ennreal_mult_right_cong:
   "((a::ennreal) \<noteq> 0 \<Longrightarrow> b = c) \<Longrightarrow> b * a = c * a"
   by (cases "a = 0") simp_all
 
 lemma ennreal_zero_less_mult_iff: "0 < a * b \<longleftrightarrow> 0 < a \<and> 0 < (b::ennreal)"
   by transfer (auto simp add: ereal_zero_less_0_iff le_less)
 
 lemma less_diff_eq_ennreal:
   fixes a b c :: ennreal
   shows "b < top \<or> c < top \<Longrightarrow> a < b - c \<longleftrightarrow> a + c < b"
   apply transfer
   subgoal for a b c
     by (cases a b c rule: ereal3_cases) (auto split: split_max)
   done
 
 lemma diff_add_cancel_ennreal:
   fixes a b :: ennreal shows "a \<le> b \<Longrightarrow> b - a + a = b"
   unfolding infinity_ennreal_def
   by transfer (metis (no_types) add.commute ereal_diff_positive ereal_ineq_diff_add max_def not_MInfty_nonneg)
 
 lemma ennreal_diff_self[simp]: "a \<noteq> top \<Longrightarrow> a - a = (0::ennreal)"
   by transfer (simp add: top_ereal_def)
 
 lemma ennreal_minus_mono:
   fixes a b c :: ennreal
   shows "a \<le> c \<Longrightarrow> d \<le> b \<Longrightarrow> a - b \<le> c - d"
   by transfer (meson ereal_minus_mono max.mono order_refl)
 
 lemma ennreal_minus_eq_top[simp]: "a - (b::ennreal) = top \<longleftrightarrow> a = top"
   by transfer (auto simp: top_ereal_def max.absorb2 ereal_minus_eq_PInfty_iff split: split_max)
 
 lemma ennreal_divide_self[simp]: "a \<noteq> 0 \<Longrightarrow> a < top \<Longrightarrow> a / a = (1::ennreal)"
   unfolding divide_ennreal_def
   apply transfer
   subgoal for a
     by (cases a) (auto simp: top_ereal_def)
   done
 
 subsection \<open>Coercion from \<^typ>\<open>real\<close> to \<^typ>\<open>ennreal\<close>\<close>
 
 lift_definition ennreal :: "real \<Rightarrow> ennreal" is "sup 0 \<circ> ereal"
   by simp
 
 declare [[coercion ennreal]]
 
 lemma ennreal_cong: "x = y \<Longrightarrow> ennreal x = ennreal y" by simp
 
 lemma ennreal_cases[cases type: ennreal]:
   fixes x :: ennreal
   obtains (real) r :: real where "0 \<le> r" "x = ennreal r" | (top) "x = top"
   apply transfer
   subgoal for x thesis
     by (cases x) (auto simp: max.absorb2 top_ereal_def)
   done
 
 lemmas ennreal2_cases = ennreal_cases[case_product ennreal_cases]
 lemmas ennreal3_cases = ennreal_cases[case_product ennreal2_cases]
 
 lemma ennreal_neq_top[simp]: "ennreal r \<noteq> top"
   by transfer (simp add: top_ereal_def zero_ereal_def flip: ereal_max)
 
 lemma top_neq_ennreal[simp]: "top \<noteq> ennreal r"
   using ennreal_neq_top[of r] by (auto simp del: ennreal_neq_top)
 
 lemma ennreal_less_top[simp]: "ennreal x < top"
   by transfer (simp add: top_ereal_def max_def)
 
 lemma ennreal_neg: "x \<le> 0 \<Longrightarrow> ennreal x = 0"
   by transfer (simp add: max.absorb1)
 
 lemma ennreal_inj[simp]:
   "0 \<le> a \<Longrightarrow> 0 \<le> b \<Longrightarrow> ennreal a = ennreal b \<longleftrightarrow> a = b"
   by (transfer fixing: a b) (auto simp: max_absorb2)
 
 lemma ennreal_le_iff[simp]: "0 \<le> y \<Longrightarrow> ennreal x \<le> ennreal y \<longleftrightarrow> x \<le> y"
   by (auto simp: ennreal_def zero_ereal_def less_eq_ennreal.abs_eq eq_onp_def split: split_max)
 
 lemma le_ennreal_iff: "0 \<le> r \<Longrightarrow> x \<le> ennreal r \<longleftrightarrow> (\<exists>q\<ge>0. x = ennreal q \<and> q \<le> r)"
   by (cases x) (auto simp: top_unique)
 
 lemma ennreal_less_iff: "0 \<le> r \<Longrightarrow> ennreal r < ennreal q \<longleftrightarrow> r < q"
   unfolding not_le[symmetric] by auto
 
 lemma ennreal_eq_zero_iff[simp]: "0 \<le> x \<Longrightarrow> ennreal x = 0 \<longleftrightarrow> x = 0"
   by transfer (auto simp: max_absorb2)
 
 lemma ennreal_less_zero_iff[simp]: "0 < ennreal x \<longleftrightarrow> 0 < x"
   by transfer (auto simp: max_def)
 
 lemma ennreal_lessI: "0 < q \<Longrightarrow> r < q \<Longrightarrow> ennreal r < ennreal q"
   by (cases "0 \<le> r") (auto simp: ennreal_less_iff ennreal_neg)
 
 lemma ennreal_leI: "x \<le> y \<Longrightarrow> ennreal x \<le> ennreal y"
   by (cases "0 \<le> y") (auto simp: ennreal_neg)
 
 lemma enn2ereal_ennreal[simp]: "0 \<le> x \<Longrightarrow> enn2ereal (ennreal x) = x"
   by transfer (simp add: max_absorb2)
 
 lemma e2ennreal_enn2ereal[simp]: "e2ennreal (enn2ereal x) = x"
   by (simp add: e2ennreal_def max_absorb2 ennreal.enn2ereal_inverse)
 
 lemma enn2ereal_e2ennreal: "x \<ge> 0 \<Longrightarrow> enn2ereal (e2ennreal x) = x"
 by (metis e2ennreal_enn2ereal ereal_ennreal_cases not_le)
 
 lemma e2ennreal_ereal [simp]: "e2ennreal (ereal x) = ennreal x"
 by (metis e2ennreal_def enn2ereal_inverse ennreal.rep_eq sup_ereal_def)
 
 lemma ennreal_0[simp]: "ennreal 0 = 0"
   by (simp add: ennreal_def max.absorb1 zero_ennreal.abs_eq)
 
 lemma ennreal_1[simp]: "ennreal 1 = 1"
   by transfer (simp add: max_absorb2)
 
 lemma ennreal_eq_0_iff: "ennreal x = 0 \<longleftrightarrow> x \<le> 0"
   by (cases "0 \<le> x") (auto simp: ennreal_neg)
 
 lemma ennreal_le_iff2: "ennreal x \<le> ennreal y \<longleftrightarrow> ((0 \<le> y \<and> x \<le> y) \<or> (x \<le> 0 \<and> y \<le> 0))"
   by (cases "0 \<le> y") (auto simp: ennreal_eq_0_iff ennreal_neg)
 
 lemma ennreal_eq_1[simp]: "ennreal x = 1 \<longleftrightarrow> x = 1"
   by (cases "0 \<le> x") (auto simp: ennreal_neg simp flip: ennreal_1)
 
 lemma ennreal_le_1[simp]: "ennreal x \<le> 1 \<longleftrightarrow> x \<le> 1"
   by (cases "0 \<le> x") (auto simp: ennreal_neg simp flip: ennreal_1)
 
 lemma ennreal_ge_1[simp]: "ennreal x \<ge> 1 \<longleftrightarrow> x \<ge> 1"
   by (cases "0 \<le> x") (auto simp: ennreal_neg simp flip: ennreal_1)
 
 lemma one_less_ennreal[simp]: "1 < ennreal x \<longleftrightarrow> 1 < x"
   by transfer (auto simp: max.absorb2 less_max_iff_disj)
 
 lemma ennreal_plus[simp]:
   "0 \<le> a \<Longrightarrow> 0 \<le> b \<Longrightarrow> ennreal (a + b) = ennreal a + ennreal b"
   by (transfer fixing: a b) (auto simp: max_absorb2)
 
 lemma add_mono_ennreal: "x < ennreal y \<Longrightarrow> x' < ennreal y' \<Longrightarrow> x + x' < ennreal (y + y')"
   by (metis (full_types) add_strict_mono ennreal_less_zero_iff ennreal_plus less_le not_less zero_le)
 
 lemma sum_ennreal[simp]: "(\<And>i. i \<in> I \<Longrightarrow> 0 \<le> f i) \<Longrightarrow> (\<Sum>i\<in>I. ennreal (f i)) = ennreal (sum f I)"
   by (induction I rule: infinite_finite_induct) (auto simp: sum_nonneg)
 
 lemma sum_list_ennreal[simp]:
   assumes "\<And>x. x \<in> set xs \<Longrightarrow> f x \<ge> 0"
   shows   "sum_list (map (\<lambda>x. ennreal (f x)) xs) = ennreal (sum_list (map f xs))"
 using assms
 proof (induction xs)
   case (Cons x xs)
   from Cons have "(\<Sum>x\<leftarrow>x # xs. ennreal (f x)) = ennreal (f x) + ennreal (sum_list (map f xs))"
     by simp
   also from Cons.prems have "\<dots> = ennreal (f x + sum_list (map f xs))"
     by (intro ennreal_plus [symmetric] sum_list_nonneg) auto
   finally show ?case by simp
 qed simp_all
 
 lemma ennreal_of_nat_eq_real_of_nat: "of_nat i = ennreal (of_nat i)"
   by (induction i) simp_all
 
 lemma of_nat_le_ennreal_iff[simp]: "0 \<le> r \<Longrightarrow> of_nat i \<le> ennreal r \<longleftrightarrow> of_nat i \<le> r"
   by (simp add: ennreal_of_nat_eq_real_of_nat)
 
 lemma ennreal_le_of_nat_iff[simp]: "ennreal r \<le> of_nat i \<longleftrightarrow> r \<le> of_nat i"
   by (simp add: ennreal_of_nat_eq_real_of_nat)
 
 lemma ennreal_indicator: "ennreal (indicator A x) = indicator A x"
   by (auto split: split_indicator)
 
 lemma ennreal_numeral[simp]: "ennreal (numeral n) = numeral n"
   using ennreal_of_nat_eq_real_of_nat[of "numeral n"] by simp
 
 lemma ennreal_less_numeral_iff [simp]: "ennreal n < numeral w \<longleftrightarrow> n < numeral w"
   by (metis ennreal_less_iff ennreal_numeral less_le not_less zero_less_numeral)
 
 lemma numeral_less_ennreal_iff [simp]: "numeral w < ennreal n \<longleftrightarrow> numeral w < n"
   using ennreal_less_iff zero_le_numeral by fastforce
 
 lemma numeral_le_ennreal_iff [simp]: "numeral n \<le> ennreal m \<longleftrightarrow> numeral n \<le> m"
   by (metis not_le ennreal_less_numeral_iff)
 
 lemma min_ennreal: "0 \<le> x \<Longrightarrow> 0 \<le> y \<Longrightarrow> min (ennreal x) (ennreal y) = ennreal (min x y)"
   by (auto split: split_min)
 
 lemma ennreal_half[simp]: "ennreal (1/2) = inverse 2"
   by transfer (simp add: max.absorb2)
 
 lemma ennreal_minus: "0 \<le> q \<Longrightarrow> ennreal r - ennreal q = ennreal (r - q)"
   by transfer
      (simp add: max.absorb2 zero_ereal_def flip: ereal_max)
 
 lemma ennreal_minus_top[simp]: "ennreal a - top = 0"
   by (simp add: minus_top_ennreal)
 
 lemma e2eenreal_enn2ereal_diff [simp]:
   "e2ennreal(enn2ereal x - enn2ereal y) = x - y" for x y
 by (cases x, cases y, auto simp add: ennreal_minus e2ennreal_neg)
 
 lemma ennreal_mult: "0 \<le> a \<Longrightarrow> 0 \<le> b \<Longrightarrow> ennreal (a * b) = ennreal a * ennreal b"
   by transfer (simp add: max_absorb2)
 
 lemma ennreal_mult': "0 \<le> a \<Longrightarrow> ennreal (a * b) = ennreal a * ennreal b"
   by (cases "0 \<le> b") (auto simp: ennreal_mult ennreal_neg mult_nonneg_nonpos)
 
 lemma indicator_mult_ennreal: "indicator A x * ennreal r = ennreal (indicator A x * r)"
   by (simp split: split_indicator)
 
 lemma ennreal_mult'': "0 \<le> b \<Longrightarrow> ennreal (a * b) = ennreal a * ennreal b"
   by (cases "0 \<le> a") (auto simp: ennreal_mult ennreal_neg mult_nonpos_nonneg)
 
 lemma numeral_mult_ennreal: "0 \<le> x \<Longrightarrow> numeral b * ennreal x = ennreal (numeral b * x)"
   by (simp add: ennreal_mult)
 
 lemma ennreal_power: "0 \<le> r \<Longrightarrow> ennreal r ^ n = ennreal (r ^ n)"
   by (induction n) (auto simp: ennreal_mult)
 
 lemma power_eq_top_ennreal: "x ^ n = top \<longleftrightarrow> (n \<noteq> 0 \<and> (x::ennreal) = top)"
   by (cases x rule: ennreal_cases)
      (auto simp: ennreal_power top_power_ennreal)
 
 lemma inverse_ennreal: "0 < r \<Longrightarrow> inverse (ennreal r) = ennreal (inverse r)"
   by transfer (simp add: max.absorb2)
 
 lemma divide_ennreal: "0 \<le> r \<Longrightarrow> 0 < q \<Longrightarrow> ennreal r / ennreal q = ennreal (r / q)"
   by (simp add: divide_ennreal_def inverse_ennreal ennreal_mult[symmetric] inverse_eq_divide)
 
 lemma ennreal_inverse_power: "inverse (x ^ n :: ennreal) = inverse x ^ n"
 proof (cases x rule: ennreal_cases)
   case top with power_eq_top_ennreal[of x n] show ?thesis
     by (cases "n = 0") auto
 next
   case (real r) then show ?thesis
   proof cases
     assume "x = 0" then show ?thesis
       using power_eq_top_ennreal[of top "n - 1"]
       by (cases n) (auto simp: ennreal_top_mult)
   next
     assume "x \<noteq> 0"
     with real have "0 < r" by auto
     with real show ?thesis
       by (induction n)
          (auto simp add: ennreal_power ennreal_mult[symmetric] inverse_ennreal)
   qed
 qed
 
 lemma power_divide_distrib_ennreal [algebra_simps]:
   "(x / y) ^ n = x ^ n / (y ^ n :: ennreal)"
   by (simp add: divide_ennreal_def algebra_simps ennreal_inverse_power)
 
 lemma ennreal_divide_numeral: "0 \<le> x \<Longrightarrow> ennreal x / numeral b = ennreal (x / numeral b)"
   by (subst divide_ennreal[symmetric]) auto
 
 lemma prod_ennreal: "(\<And>i. i \<in> A \<Longrightarrow> 0 \<le> f i) \<Longrightarrow> (\<Prod>i\<in>A. ennreal (f i)) = ennreal (prod f A)"
   by (induction A rule: infinite_finite_induct)
      (auto simp: ennreal_mult prod_nonneg)
 
 lemma prod_mono_ennreal:
   assumes "\<And>x. x \<in> A \<Longrightarrow> f x \<le> (g x :: ennreal)"
   shows   "prod f A \<le> prod g A"
   using assms by (induction A rule: infinite_finite_induct) (auto intro!: mult_mono)
 
 lemma mult_right_ennreal_cancel: "a * ennreal c = b * ennreal c \<longleftrightarrow> (a = b \<or> c \<le> 0)"
 proof (cases "0 \<le> c")
   case True
   then show ?thesis
     by (metis ennreal_eq_0_iff ennreal_mult_right_cong ennreal_neq_top mult_divide_eq_ennreal)
 qed (use ennreal_neg in auto)
 
 lemma ennreal_le_epsilon:
   "(\<And>e::real. y < top \<Longrightarrow> 0 < e \<Longrightarrow> x \<le> y + ennreal e) \<Longrightarrow> x \<le> y"
   apply (cases y rule: ennreal_cases)
   apply (cases x rule: ennreal_cases)
   apply (auto simp flip: ennreal_plus simp add: top_unique intro: zero_less_one field_le_epsilon)
   done
 
 lemma ennreal_rat_dense:
   fixes x y :: ennreal
   shows "x < y \<Longrightarrow> \<exists>r::rat. x < real_of_rat r \<and> real_of_rat r < y"
 proof transfer
   fix x y :: ereal assume xy: "0 \<le> x" "0 \<le> y" "x < y"
   moreover
   from ereal_dense3[OF \<open>x < y\<close>]
   obtain r where r: "x < ereal (real_of_rat r)" "ereal (real_of_rat r) < y"
     by auto
   then have "0 \<le> r"
     using le_less_trans[OF \<open>0 \<le> x\<close> \<open>x < ereal (real_of_rat r)\<close>] by auto
   with r show "\<exists>r. x < (sup 0 \<circ> ereal) (real_of_rat r) \<and> (sup 0 \<circ> ereal) (real_of_rat r) < y"
     by (intro exI[of _ r]) (auto simp: max_absorb2)
 qed
 
 lemma ennreal_Ex_less_of_nat: "(x::ennreal) < top \<Longrightarrow> \<exists>n. x < of_nat n"
   by (cases x rule: ennreal_cases)
      (auto simp: ennreal_of_nat_eq_real_of_nat ennreal_less_iff reals_Archimedean2)
 
 subsection \<open>Coercion from \<^typ>\<open>ennreal\<close> to \<^typ>\<open>real\<close>\<close>
 
 definition "enn2real x = real_of_ereal (enn2ereal x)"
 
 lemma enn2real_nonneg[simp]: "0 \<le> enn2real x"
   by (auto simp: enn2real_def intro!: real_of_ereal_pos enn2ereal_nonneg)
 
 lemma enn2real_mono: "a \<le> b \<Longrightarrow> b < top \<Longrightarrow> enn2real a \<le> enn2real b"
   by (auto simp add: enn2real_def less_eq_ennreal.rep_eq intro!: real_of_ereal_positive_mono enn2ereal_nonneg)
 
 lemma enn2real_of_nat[simp]: "enn2real (of_nat n) = n"
   by (auto simp: enn2real_def)
 
 lemma enn2real_ennreal[simp]: "0 \<le> r \<Longrightarrow> enn2real (ennreal r) = r"
   by (simp add: enn2real_def)
 
 lemma ennreal_enn2real[simp]: "r < top \<Longrightarrow> ennreal (enn2real r) = r"
   by (cases r rule: ennreal_cases) auto
 
 lemma real_of_ereal_enn2ereal[simp]: "real_of_ereal (enn2ereal x) = enn2real x"
   by (simp add: enn2real_def)
 
 lemma enn2real_top[simp]: "enn2real top = 0"
   unfolding enn2real_def top_ennreal.rep_eq top_ereal_def by simp
 
 lemma enn2real_0[simp]: "enn2real 0 = 0"
   unfolding enn2real_def zero_ennreal.rep_eq by simp
 
 lemma enn2real_1[simp]: "enn2real 1 = 1"
   unfolding enn2real_def one_ennreal.rep_eq by simp
 
 lemma enn2real_numeral[simp]: "enn2real (numeral n) = (numeral n)"
   unfolding enn2real_def by simp
 
 lemma enn2real_mult: "enn2real (a * b) = enn2real a * enn2real b"
   unfolding enn2real_def
   by (simp del: real_of_ereal_enn2ereal add: times_ennreal.rep_eq)
 
 lemma enn2real_leI: "0 \<le> B \<Longrightarrow> x \<le> ennreal B \<Longrightarrow> enn2real x \<le> B"
   by (cases x rule: ennreal_cases) (auto simp: top_unique)
 
 lemma enn2real_positive_iff: "0 < enn2real x \<longleftrightarrow> (0 < x \<and> x < top)"
   by (cases x rule: ennreal_cases) auto
 
 lemma enn2real_eq_posreal_iff[simp]: "c > 0 \<Longrightarrow> enn2real x = c \<longleftrightarrow> x = c"
   by (cases x) auto
 
 lemma ennreal_enn2real_if: "ennreal (enn2real r) = (if r = top then 0 else r)"
   by(auto intro!: ennreal_enn2real simp add: less_top)
 
 subsection \<open>Coercion from \<^typ>\<open>enat\<close> to \<^typ>\<open>ennreal\<close>\<close>
 
 
 definition ennreal_of_enat :: "enat \<Rightarrow> ennreal"
 where
   "ennreal_of_enat n = (case n of \<infinity> \<Rightarrow> top | enat n \<Rightarrow> of_nat n)"
 
 declare [[coercion ennreal_of_enat]]
 declare [[coercion "of_nat :: nat \<Rightarrow> ennreal"]]
 
 lemma ennreal_of_enat_infty[simp]: "ennreal_of_enat \<infinity> = \<infinity>"
   by (simp add: ennreal_of_enat_def)
 
 lemma ennreal_of_enat_enat[simp]: "ennreal_of_enat (enat n) = of_nat n"
   by (simp add: ennreal_of_enat_def)
 
 lemma ennreal_of_enat_0[simp]: "ennreal_of_enat 0 = 0"
   using ennreal_of_enat_enat[of 0] unfolding enat_0 by simp
 
 lemma ennreal_of_enat_1[simp]: "ennreal_of_enat 1 = 1"
   using ennreal_of_enat_enat[of 1] unfolding enat_1 by simp
 
 lemma ennreal_top_neq_of_nat[simp]: "(top::ennreal) \<noteq> of_nat i"
   using ennreal_of_nat_neq_top[of i] by metis
 
 lemma ennreal_of_enat_inj[simp]: "ennreal_of_enat i = ennreal_of_enat j \<longleftrightarrow> i = j"
   by (cases i j rule: enat.exhaust[case_product enat.exhaust]) auto
 
 lemma ennreal_of_enat_le_iff[simp]: "ennreal_of_enat m \<le> ennreal_of_enat n \<longleftrightarrow> m \<le> n"
   by (auto simp: ennreal_of_enat_def top_unique split: enat.split)
 
 lemma of_nat_less_ennreal_of_nat[simp]: "of_nat n \<le> ennreal_of_enat x \<longleftrightarrow> of_nat n \<le> x"
   by (cases x) (auto simp: of_nat_eq_enat)
 
 lemma ennreal_of_enat_Sup: "ennreal_of_enat (Sup X) = (SUP x\<in>X. ennreal_of_enat x)"
 proof -
   have "ennreal_of_enat (Sup X) \<le> (SUP x \<in> X. ennreal_of_enat x)"
     unfolding Sup_enat_def
   proof (clarsimp, intro conjI impI)
     fix x assume "finite X" "X \<noteq> {}"
     then show "ennreal_of_enat (Max X) \<le> (SUP x \<in> X. ennreal_of_enat x)"
       by (intro SUP_upper Max_in)
   next
     assume "infinite X" "X \<noteq> {}"
     have "\<exists>y\<in>X. r < ennreal_of_enat y" if r: "r < top" for r
     proof -
-      from ennreal_Ex_less_of_nat[OF r] guess n .. note n = this
+      obtain n where n: "r < of_nat n"
+        using ennreal_Ex_less_of_nat[OF r] ..
       have "\<not> (X \<subseteq> enat ` {.. n})"
         using \<open>infinite X\<close> by (auto dest: finite_subset)
       then obtain x where x: "x \<in> X" "x \<notin> enat ` {..n}"
         by blast
       then have "of_nat n \<le> x"
         by (cases x) (auto simp: of_nat_eq_enat)
       with x show ?thesis
         by (auto intro!: bexI[of _ x] less_le_trans[OF n])
     qed
     then have "(SUP x \<in> X. ennreal_of_enat x) = top"
       by simp
     then show "top \<le> (SUP x \<in> X. ennreal_of_enat x)"
       unfolding top_unique by simp
   qed
   then show ?thesis
     by (auto intro!: antisym Sup_least intro: Sup_upper)
 qed
 
 lemma ennreal_of_enat_eSuc[simp]: "ennreal_of_enat (eSuc x) = 1 + ennreal_of_enat x"
   by (cases x) (auto simp: eSuc_enat)
 
 subsection \<open>Topology on \<^typ>\<open>ennreal\<close>\<close>
 
 lemma enn2ereal_Iio: "enn2ereal -` {..<a} = (if 0 \<le> a then {..< e2ennreal a} else {})"
   using enn2ereal_nonneg
   by (cases a rule: ereal_ennreal_cases)
      (auto simp add: vimage_def set_eq_iff ennreal.enn2ereal_inverse less_ennreal.rep_eq e2ennreal_def max_absorb2
            simp del: enn2ereal_nonneg
            intro: le_less_trans less_imp_le)
 
 lemma enn2ereal_Ioi: "enn2ereal -` {a <..} = (if 0 \<le> a then {e2ennreal a <..} else UNIV)"
   by (cases a rule: ereal_ennreal_cases)
      (auto simp add: vimage_def set_eq_iff ennreal.enn2ereal_inverse less_ennreal.rep_eq e2ennreal_def max_absorb2
            intro: less_le_trans)
 
 instantiation ennreal :: linear_continuum_topology
 begin
 
 definition open_ennreal :: "ennreal set \<Rightarrow> bool"
   where "(open :: ennreal set \<Rightarrow> bool) = generate_topology (range lessThan \<union> range greaterThan)"
 
 instance
 proof
   show "\<exists>a b::ennreal. a \<noteq> b"
     using zero_neq_one by (intro exI)
   show "\<And>x y::ennreal. x < y \<Longrightarrow> \<exists>z>x. z < y"
   proof transfer
-    fix x y :: ereal assume "0 \<le> x" and *: "x < y"
-    moreover from dense[OF *] guess z ..
-    ultimately show "\<exists>z\<in>Collect ((\<le>) 0). x < z \<and> z < y"
+    fix x y :: ereal
+    assume *: "0 \<le> x"
+    assume "x < y"
+    from dense[OF this] obtain z where "x < z \<and> z < y" ..
+    with * show "\<exists>z\<in>Collect ((\<le>) 0). x < z \<and> z < y"
       by (intro bexI[of _ z]) auto
   qed
 qed (rule open_ennreal_def)
 
 end
 
 lemma continuous_on_e2ennreal: "continuous_on A e2ennreal"
 proof (rule continuous_on_subset)
   show "continuous_on ({0..} \<union> {..0}) e2ennreal"
   proof (rule continuous_on_closed_Un)
     show "continuous_on {0 ..} e2ennreal"
       by (rule continuous_onI_mono)
          (auto simp add: less_eq_ennreal.abs_eq eq_onp_def enn2ereal_range)
     show "continuous_on {.. 0} e2ennreal"
       by (subst continuous_on_cong[OF refl, of _ _ "\<lambda>_. 0"])
          (auto simp add: e2ennreal_neg continuous_on_const)
   qed auto
   show "A \<subseteq> {0..} \<union> {..0::ereal}"
     by auto
 qed
 
 lemma continuous_at_e2ennreal: "continuous (at x within A) e2ennreal"
   by (rule continuous_on_imp_continuous_within[OF continuous_on_e2ennreal, of _ UNIV]) auto
 
 lemma continuous_on_enn2ereal: "continuous_on UNIV enn2ereal"
   by (rule continuous_on_generate_topology[OF open_generated_order])
      (auto simp add: enn2ereal_Iio enn2ereal_Ioi)
 
 lemma continuous_at_enn2ereal: "continuous (at x within A) enn2ereal"
   by (rule continuous_on_imp_continuous_within[OF continuous_on_enn2ereal]) auto
 
 lemma sup_continuous_e2ennreal[order_continuous_intros]:
   assumes f: "sup_continuous f" shows "sup_continuous (\<lambda>x. e2ennreal (f x))"
 proof (rule sup_continuous_compose[OF _ f])
   show "sup_continuous e2ennreal"
     by (simp add: continuous_at_e2ennreal continuous_at_left_imp_sup_continuous e2ennreal_mono mono_def)
 qed
 
 lemma sup_continuous_enn2ereal[order_continuous_intros]:
   assumes f: "sup_continuous f" shows "sup_continuous (\<lambda>x. enn2ereal (f x))"
 proof (rule sup_continuous_compose[OF _ f])
   show "sup_continuous enn2ereal"
   by (simp add: continuous_at_enn2ereal continuous_at_left_imp_sup_continuous less_eq_ennreal.rep_eq mono_def)
 qed
 
 lemma sup_continuous_mult_left_ennreal':
   fixes c :: "ennreal"
   shows "sup_continuous (\<lambda>x. c * x)"
   unfolding sup_continuous_def
   by transfer (auto simp: SUP_ereal_mult_left max.absorb2 SUP_upper2)
 
 lemma sup_continuous_mult_left_ennreal[order_continuous_intros]:
   "sup_continuous f \<Longrightarrow> sup_continuous (\<lambda>x. c * f x :: ennreal)"
   by (rule sup_continuous_compose[OF sup_continuous_mult_left_ennreal'])
 
 lemma sup_continuous_mult_right_ennreal[order_continuous_intros]:
   "sup_continuous f \<Longrightarrow> sup_continuous (\<lambda>x. f x * c :: ennreal)"
   using sup_continuous_mult_left_ennreal[of f c] by (simp add: mult.commute)
 
 lemma sup_continuous_divide_ennreal[order_continuous_intros]:
   fixes f g :: "'a::complete_lattice \<Rightarrow> ennreal"
   shows "sup_continuous f \<Longrightarrow> sup_continuous (\<lambda>x. f x / c)"
   unfolding divide_ennreal_def by (rule sup_continuous_mult_right_ennreal)
 
 lemma transfer_enn2ereal_continuous_on [transfer_rule]:
   "rel_fun (=) (rel_fun (rel_fun (=) pcr_ennreal) (=)) continuous_on continuous_on"
 proof -
   have "continuous_on A f" if "continuous_on A (\<lambda>x. enn2ereal (f x))" for A and f :: "'a \<Rightarrow> ennreal"
     using continuous_on_compose2[OF continuous_on_e2ennreal[of "{0..}"] that]
     by (auto simp: ennreal.enn2ereal_inverse subset_eq e2ennreal_def max_absorb2)
   moreover
   have "continuous_on A (\<lambda>x. enn2ereal (f x))" if "continuous_on A f" for A and f :: "'a \<Rightarrow> ennreal"
     using continuous_on_compose2[OF continuous_on_enn2ereal that] by auto
   ultimately
   show ?thesis
     by (auto simp add: rel_fun_def ennreal.pcr_cr_eq cr_ennreal_def)
 qed
 
 lemma transfer_sup_continuous[transfer_rule]:
   "(rel_fun (rel_fun (=) pcr_ennreal) (=)) sup_continuous sup_continuous"
 proof (safe intro!: rel_funI dest!: rel_fun_eq_pcr_ennreal[THEN iffD1])
   show "sup_continuous (enn2ereal \<circ> f) \<Longrightarrow> sup_continuous f" for f :: "'a \<Rightarrow> _"
     using sup_continuous_e2ennreal[of "enn2ereal \<circ> f"] by simp
   show "sup_continuous f \<Longrightarrow> sup_continuous (enn2ereal \<circ> f)" for f :: "'a \<Rightarrow> _"
     using sup_continuous_enn2ereal[of f] by (simp add: comp_def)
 qed
 
 lemma continuous_on_ennreal[tendsto_intros]:
   "continuous_on A f \<Longrightarrow> continuous_on A (\<lambda>x. ennreal (f x))"
   by transfer (auto intro!: continuous_on_max continuous_on_const continuous_on_ereal)
 
 lemma tendsto_ennrealD:
   assumes lim: "((\<lambda>x. ennreal (f x)) \<longlongrightarrow> ennreal x) F"
   assumes *: "\<forall>\<^sub>F x in F. 0 \<le> f x" and x: "0 \<le> x"
   shows "(f \<longlongrightarrow> x) F"
 proof -
   have "((\<lambda>x. enn2ereal (ennreal (f x))) \<longlongrightarrow> enn2ereal (ennreal x)) F 
     \<longleftrightarrow> (f \<longlongrightarrow> enn2ereal (ennreal x)) F"
     using "*" eventually_mono
     by (intro tendsto_cong) fastforce
   then show ?thesis
     using assms(1) continuous_at_enn2ereal isCont_tendsto_compose x by fastforce
 qed
 
 lemma tendsto_ennreal_iff [simp]:
   \<open>((\<lambda>x. ennreal (f x)) \<longlongrightarrow> ennreal x) F \<longleftrightarrow> (f \<longlongrightarrow> x) F\<close> (is \<open>?P \<longleftrightarrow> ?Q\<close>)
   if \<open>\<forall>\<^sub>F x in F. 0 \<le> f x\<close> \<open>0 \<le> x\<close>
 proof
   assume \<open>?P\<close>
   then show \<open>?Q\<close>
     using that by (rule tendsto_ennrealD)
 next
   assume \<open>?Q\<close>
   have \<open>continuous_on UNIV ereal\<close>
     using continuous_on_ereal [of _ id] by simp
   then have \<open>continuous_on UNIV (e2ennreal \<circ> ereal)\<close>
     by (rule continuous_on_compose) (simp_all add: continuous_on_e2ennreal)
   then have \<open>((\<lambda>x. (e2ennreal \<circ> ereal) (f x)) \<longlongrightarrow> (e2ennreal \<circ> ereal) x) F\<close>
     using \<open>?Q\<close> by (rule continuous_on_tendsto_compose) simp_all
   then show \<open>?P\<close>
     by (simp flip: e2ennreal_ereal)
 qed
 
 lemma tendsto_enn2ereal_iff[simp]: "((\<lambda>i. enn2ereal (f i)) \<longlongrightarrow> enn2ereal x) F \<longleftrightarrow> (f \<longlongrightarrow> x) F"
   using continuous_on_enn2ereal[THEN continuous_on_tendsto_compose, of f x F]
     continuous_on_e2ennreal[THEN continuous_on_tendsto_compose, of "\<lambda>x. enn2ereal (f x)" "enn2ereal x" F UNIV]
   by auto
 
 lemma ennreal_tendsto_0_iff: "(\<And>n. f n \<ge> 0) \<Longrightarrow> ((\<lambda>n. ennreal (f n)) \<longlonglongrightarrow> 0) \<longleftrightarrow> (f \<longlonglongrightarrow> 0)"
   by (metis (mono_tags) ennreal_0 eventuallyI order_refl tendsto_ennreal_iff)
     
 lemma continuous_on_add_ennreal:
   fixes f g :: "'a::topological_space \<Rightarrow> ennreal"
   shows "continuous_on A f \<Longrightarrow> continuous_on A g \<Longrightarrow> continuous_on A (\<lambda>x. f x + g x)"
   by (transfer fixing: A) (auto intro!: tendsto_add_ereal_nonneg simp: continuous_on_def)
 
 lemma continuous_on_inverse_ennreal[continuous_intros]:
   fixes f :: "'a::topological_space \<Rightarrow> ennreal"
   shows "continuous_on A f \<Longrightarrow> continuous_on A (\<lambda>x. inverse (f x))"
 proof (transfer fixing: A)
   show "pred_fun top  ((\<le>) 0) f \<Longrightarrow> continuous_on A (\<lambda>x. inverse (f x))" if "continuous_on A f"
     for f :: "'a \<Rightarrow> ereal"
     using continuous_on_compose2[OF continuous_on_inverse_ereal that] by (auto simp: subset_eq)
 qed
 
 instance ennreal :: topological_comm_monoid_add
 proof
   show "((\<lambda>x. fst x + snd x) \<longlongrightarrow> a + b) (nhds a \<times>\<^sub>F nhds b)" for a b :: ennreal
     using continuous_on_add_ennreal[of UNIV fst snd]
     using tendsto_at_iff_tendsto_nhds[symmetric, of "\<lambda>x::(ennreal \<times> ennreal). fst x + snd x"]
     by (auto simp: continuous_on_eq_continuous_at)
        (simp add: isCont_def nhds_prod[symmetric])
 qed
 
 lemma sup_continuous_add_ennreal[order_continuous_intros]:
   fixes f g :: "'a::complete_lattice \<Rightarrow> ennreal"
   shows "sup_continuous f \<Longrightarrow> sup_continuous g \<Longrightarrow> sup_continuous (\<lambda>x. f x + g x)"
   by transfer (auto intro!: sup_continuous_add)
 
 lemma ennreal_suminf_lessD: "(\<Sum>i. f i :: ennreal) < x \<Longrightarrow> f i < x"
   using le_less_trans[OF sum_le_suminf[OF summableI, of "{i}" f]] by simp
 
 lemma sums_ennreal[simp]: "(\<And>i. 0 \<le> f i) \<Longrightarrow> 0 \<le> x \<Longrightarrow> (\<lambda>i. ennreal (f i)) sums ennreal x \<longleftrightarrow> f sums x"
   unfolding sums_def by (simp add: always_eventually sum_nonneg)
 
 lemma summable_suminf_not_top: "(\<And>i. 0 \<le> f i) \<Longrightarrow> (\<Sum>i. ennreal (f i)) \<noteq> top \<Longrightarrow> summable f"
   using summable_sums[OF summableI, of "\<lambda>i. ennreal (f i)"]
   by (cases "\<Sum>i. ennreal (f i)" rule: ennreal_cases)
      (auto simp: summable_def)
 
 lemma suminf_ennreal[simp]:
   "(\<And>i. 0 \<le> f i) \<Longrightarrow> (\<Sum>i. ennreal (f i)) \<noteq> top \<Longrightarrow> (\<Sum>i. ennreal (f i)) = ennreal (\<Sum>i. f i)"
   by (rule sums_unique[symmetric]) (simp add: summable_suminf_not_top suminf_nonneg summable_sums)
 
 lemma sums_enn2ereal[simp]: "(\<lambda>i. enn2ereal (f i)) sums enn2ereal x \<longleftrightarrow> f sums x"
   unfolding sums_def by (simp add: always_eventually sum_nonneg)
 
 lemma suminf_enn2ereal[simp]: "(\<Sum>i. enn2ereal (f i)) = enn2ereal (suminf f)"
   by (rule sums_unique[symmetric]) (simp add: summable_sums)
 
 lemma transfer_e2ennreal_suminf [transfer_rule]: "rel_fun (rel_fun (=) pcr_ennreal) pcr_ennreal suminf suminf"
   by (auto simp: rel_funI rel_fun_eq_pcr_ennreal comp_def)
 
 lemma ennreal_suminf_cmult[simp]: "(\<Sum>i. r * f i) = r * (\<Sum>i. f i::ennreal)"
   by transfer (auto intro!: suminf_cmult_ereal)
 
 lemma ennreal_suminf_multc[simp]: "(\<Sum>i. f i * r) = (\<Sum>i. f i::ennreal) * r"
   using ennreal_suminf_cmult[of r f] by (simp add: ac_simps)
 
 lemma ennreal_suminf_divide[simp]: "(\<Sum>i. f i / r) = (\<Sum>i. f i::ennreal) / r"
   by (simp add: divide_ennreal_def)
 
 lemma ennreal_suminf_neq_top: "summable f \<Longrightarrow> (\<And>i. 0 \<le> f i) \<Longrightarrow> (\<Sum>i. ennreal (f i)) \<noteq> top"
   using sums_ennreal[of f "suminf f"]
   by (simp add: suminf_nonneg flip: sums_unique summable_sums_iff del: sums_ennreal)
 
 lemma suminf_ennreal_eq:
   "(\<And>i. 0 \<le> f i) \<Longrightarrow> f sums x \<Longrightarrow> (\<Sum>i. ennreal (f i)) = ennreal x"
   using suminf_nonneg[of f] sums_unique[of f x]
   by (intro sums_unique[symmetric]) (auto simp: summable_sums_iff)
 
 lemma ennreal_suminf_bound_add:
   fixes f :: "nat \<Rightarrow> ennreal"
   shows "(\<And>N. (\<Sum>n<N. f n) + y \<le> x) \<Longrightarrow> suminf f + y \<le> x"
   by transfer (auto intro!: suminf_bound_add)
 
 lemma ennreal_suminf_SUP_eq_directed:
   fixes f :: "'a \<Rightarrow> nat \<Rightarrow> ennreal"
   assumes *: "\<And>N i j. i \<in> I \<Longrightarrow> j \<in> I \<Longrightarrow> finite N \<Longrightarrow> \<exists>k\<in>I. \<forall>n\<in>N. f i n \<le> f k n \<and> f j n \<le> f k n"
   shows "(\<Sum>n. SUP i\<in>I. f i n) = (SUP i\<in>I. \<Sum>n. f i n)"
 proof cases
   assume "I \<noteq> {}"
   then obtain i where "i \<in> I" by auto
   from * show ?thesis
     by (transfer fixing: I)
        (auto simp: max_absorb2 SUP_upper2[OF \<open>i \<in> I\<close>] suminf_nonneg summable_ereal_pos \<open>I \<noteq> {}\<close>
              intro!: suminf_SUP_eq_directed)
 qed (simp add: bot_ennreal)
 
 lemma INF_ennreal_add_const:
   fixes f g :: "nat \<Rightarrow> ennreal"
   shows "(INF i. f i + c) = (INF i. f i) + c"
   using continuous_at_Inf_mono[of "\<lambda>x. x + c" "f`UNIV"]
   using continuous_add[of "at_right (Inf (range f))", of "\<lambda>x. x" "\<lambda>x. c"]
   by (auto simp: mono_def image_comp)
 
 lemma INF_ennreal_const_add:
   fixes f g :: "nat \<Rightarrow> ennreal"
   shows "(INF i. c + f i) = c + (INF i. f i)"
   using INF_ennreal_add_const[of f c] by (simp add: ac_simps)
 
 lemma SUP_mult_left_ennreal: "c * (SUP i\<in>I. f i) = (SUP i\<in>I. c * f i ::ennreal)"
 proof cases
   assume "I \<noteq> {}" then show ?thesis
     by transfer (auto simp add: SUP_ereal_mult_left max_absorb2 SUP_upper2)
 qed (simp add: bot_ennreal)
 
 lemma SUP_mult_right_ennreal: "(SUP i\<in>I. f i) * c = (SUP i\<in>I. f i * c ::ennreal)"
   using SUP_mult_left_ennreal by (simp add: mult.commute)
 
 lemma SUP_divide_ennreal: "(SUP i\<in>I. f i) / c = (SUP i\<in>I. f i / c ::ennreal)"
   using SUP_mult_right_ennreal by (simp add: divide_ennreal_def)
 
 lemma ennreal_SUP_of_nat_eq_top: "(SUP x. of_nat x :: ennreal) = top"
 proof (intro antisym top_greatest le_SUP_iff[THEN iffD2] allI impI)
   fix y :: ennreal assume "y < top"
   then obtain r where "y = ennreal r"
     by (cases y rule: ennreal_cases) auto
   then show "\<exists>i\<in>UNIV. y < of_nat i"
     using reals_Archimedean2[of "max 1 r"] zero_less_one
     by (simp add: ennreal_Ex_less_of_nat)
 qed
 
 lemma ennreal_SUP_eq_top:
   fixes f :: "'a \<Rightarrow> ennreal"
   assumes "\<And>n. \<exists>i\<in>I. of_nat n \<le> f i"
   shows "(SUP i \<in> I. f i) = top"
 proof -
   have "(SUP x. of_nat x :: ennreal) \<le> (SUP i \<in> I. f i)"
     using assms by (auto intro!: SUP_least intro: SUP_upper2)
   then show ?thesis
     by (auto simp: ennreal_SUP_of_nat_eq_top top_unique)
 qed
 
 lemma ennreal_INF_const_minus:
   fixes f :: "'a \<Rightarrow> ennreal"
   shows "I \<noteq> {} \<Longrightarrow> (SUP x\<in>I. c - f x) = c - (INF x\<in>I. f x)"
   by (transfer fixing: I)
      (simp add: sup_max[symmetric] SUP_sup_const1 SUP_ereal_minus_right del: sup_ereal_def)
 
 lemma of_nat_Sup_ennreal:
   assumes "A \<noteq> {}" "bdd_above A"
   shows "of_nat (Sup A) = (SUP a\<in>A. of_nat a :: ennreal)"
 proof (intro antisym)
   show "(SUP a\<in>A. of_nat a::ennreal) \<le> of_nat (Sup A)"
     by (intro SUP_least of_nat_mono) (auto intro: cSup_upper assms)
   have "Sup A \<in> A"
     using assms by (auto simp: Sup_nat_def bdd_above_nat)
   then show "of_nat (Sup A) \<le> (SUP a\<in>A. of_nat a::ennreal)"
     by (intro SUP_upper)
 qed
 
 lemma ennreal_tendsto_const_minus:
   fixes g :: "'a \<Rightarrow> ennreal"
   assumes ae: "\<forall>\<^sub>F x in F. g x \<le> c"
   assumes g: "((\<lambda>x. c - g x) \<longlongrightarrow> 0) F"
   shows "(g \<longlongrightarrow> c) F"
 proof (cases c rule: ennreal_cases)
   case top with tendsto_unique[OF _ g, of "top"] show ?thesis
     by (cases "F = bot") auto
 next
   case (real r)
   then have "\<forall>x. \<exists>q\<ge>0. g x \<le> c \<longrightarrow> (g x = ennreal q \<and> q \<le> r)"
     by (auto simp: le_ennreal_iff)
   then obtain f where *: "0 \<le> f x" "g x = ennreal (f x)" "f x \<le> r" if "g x \<le> c" for x
     by metis
   from ae have ae2: "\<forall>\<^sub>F x in F. c - g x = ennreal (r - f x) \<and> f x \<le> r \<and> g x = ennreal (f x) \<and> 0 \<le> f x"
   proof eventually_elim
     fix x assume "g x \<le> c" with *[of x] \<open>0 \<le> r\<close> show "c - g x = ennreal (r - f x) \<and> f x \<le> r \<and> g x = ennreal (f x) \<and> 0 \<le> f x"
       by (auto simp: real ennreal_minus)
   qed
   with g have "((\<lambda>x. ennreal (r - f x)) \<longlongrightarrow> ennreal 0) F"
     by (auto simp add: tendsto_cong eventually_conj_iff)
   with ae2 have "((\<lambda>x. r - f x) \<longlongrightarrow> 0) F"
     by (subst (asm) tendsto_ennreal_iff) (auto elim: eventually_mono)
   then have "(f \<longlongrightarrow> r) F"
     by (rule Lim_transform2[OF tendsto_const])
   with ae2 have "((\<lambda>x. ennreal (f x)) \<longlongrightarrow> ennreal r) F"
     by (subst tendsto_ennreal_iff) (auto elim: eventually_mono simp: real)
   with ae2 show ?thesis
     by (auto simp: real tendsto_cong eventually_conj_iff)
 qed
 
 lemma ennreal_SUP_add:
   fixes f g :: "nat \<Rightarrow> ennreal"
   shows "incseq f \<Longrightarrow> incseq g \<Longrightarrow> (SUP i. f i + g i) = Sup (f ` UNIV) + Sup (g ` UNIV)"
   unfolding incseq_def le_fun_def
   by transfer
      (simp add: SUP_ereal_add incseq_def le_fun_def max_absorb2 SUP_upper2)
 
 lemma ennreal_SUP_sum:
   fixes f :: "'a \<Rightarrow> nat \<Rightarrow> ennreal"
   shows "(\<And>i. i \<in> I \<Longrightarrow> incseq (f i)) \<Longrightarrow> (SUP n. \<Sum>i\<in>I. f i n) = (\<Sum>i\<in>I. SUP n. f i n)"
   unfolding incseq_def
   by transfer
      (simp add: SUP_ereal_sum incseq_def SUP_upper2 max_absorb2 sum_nonneg)
 
 lemma ennreal_liminf_minus:
   fixes f :: "nat \<Rightarrow> ennreal"
   shows "(\<And>n. f n \<le> c) \<Longrightarrow> liminf (\<lambda>n. c - f n) = c - limsup f"
   apply transfer
   apply (simp add: ereal_diff_positive max.absorb2 liminf_ereal_cminus)
   apply (subst max.absorb2)
   apply (rule ereal_diff_positive)
   apply (rule Limsup_bounded)
   apply auto
   done
 
 lemma ennreal_continuous_on_cmult:
   "(c::ennreal) < top \<Longrightarrow> continuous_on A f \<Longrightarrow> continuous_on A (\<lambda>x. c * f x)"
   by (transfer fixing: A) (auto intro: continuous_on_cmult_ereal)
 
 lemma ennreal_tendsto_cmult:
   "(c::ennreal) < top \<Longrightarrow> (f \<longlongrightarrow> x) F \<Longrightarrow> ((\<lambda>x. c * f x) \<longlongrightarrow> c * x) F"
   by (rule continuous_on_tendsto_compose[where g=f, OF ennreal_continuous_on_cmult, where s=UNIV])
      (auto simp: continuous_on_id)
 
 lemma tendsto_ennrealI[intro, simp, tendsto_intros]:
   "(f \<longlongrightarrow> x) F \<Longrightarrow> ((\<lambda>x. ennreal (f x)) \<longlongrightarrow> ennreal x) F"
   by (auto simp: ennreal_def
            intro!: continuous_on_tendsto_compose[OF continuous_on_e2ennreal[of UNIV]] tendsto_max)
 
 lemma tendsto_enn2erealI [tendsto_intros]:
   assumes "(f \<longlongrightarrow> l) F"
   shows "((\<lambda>i. enn2ereal(f i)) \<longlongrightarrow> enn2ereal l) F"
 using tendsto_enn2ereal_iff assms by auto
 
 lemma tendsto_e2ennrealI [tendsto_intros]:
   assumes "(f \<longlongrightarrow> l) F"
   shows "((\<lambda>i. e2ennreal(f i)) \<longlongrightarrow> e2ennreal l) F"
 proof -
   have *: "e2ennreal (max x 0) = e2ennreal x" for x
     by (simp add: e2ennreal_def max.commute)
   have "((\<lambda>i. max (f i) 0) \<longlongrightarrow> max l 0) F"
     apply (intro tendsto_intros) using assms by auto
   then have "((\<lambda>i. enn2ereal(e2ennreal (max (f i) 0))) \<longlongrightarrow> enn2ereal (e2ennreal (max l 0))) F"
     by (subst enn2ereal_e2ennreal, auto)+
   then have "((\<lambda>i. e2ennreal (max (f i) 0)) \<longlongrightarrow> e2ennreal (max l 0)) F"
     using tendsto_enn2ereal_iff by auto
   then show ?thesis
     unfolding * by auto
 qed
 
 lemma ennreal_suminf_minus:
   fixes f g :: "nat \<Rightarrow> ennreal"
   shows "(\<And>i. g i \<le> f i) \<Longrightarrow> suminf f \<noteq> top \<Longrightarrow> suminf g \<noteq> top \<Longrightarrow> (\<Sum>i. f i - g i) = suminf f - suminf g"
   by transfer
      (auto simp add: max.absorb2 ereal_diff_positive suminf_le_pos top_ereal_def intro!: suminf_ereal_minus)
 
 lemma ennreal_Sup_countable_SUP:
   "A \<noteq> {} \<Longrightarrow> \<exists>f::nat \<Rightarrow> ennreal. incseq f \<and> range f \<subseteq> A \<and> Sup A = (SUP i. f i)"
   unfolding incseq_def
   apply transfer
   subgoal for A
     using Sup_countable_SUP[of A]
     by (force simp add: incseq_def[symmetric] SUP_upper2 max.absorb2 image_subset_iff Sup_upper2 cong: conj_cong)
   done
 
 lemma ennreal_Inf_countable_INF:
   "A \<noteq> {} \<Longrightarrow> \<exists>f::nat \<Rightarrow> ennreal. decseq f \<and> range f \<subseteq> A \<and> Inf A = (INF i. f i)"
   including ennreal.lifting
   unfolding decseq_def
   apply transfer
   subgoal for A
     using Inf_countable_INF[of A]
     apply (clarsimp simp flip: decseq_def)
     subgoal for f
       by (intro exI[of _ f]) auto
     done
   done
 
 lemma ennreal_SUP_countable_SUP:
   "A \<noteq> {} \<Longrightarrow> \<exists>f::nat \<Rightarrow> ennreal. range f \<subseteq> g`A \<and> Sup (g ` A) = Sup (f ` UNIV)"
   using ennreal_Sup_countable_SUP [of "g`A"] by auto
 
 lemma of_nat_tendsto_top_ennreal: "(\<lambda>n::nat. of_nat n :: ennreal) \<longlonglongrightarrow> top"
   using LIMSEQ_SUP[of "of_nat :: nat \<Rightarrow> ennreal"]
   by (simp add: ennreal_SUP_of_nat_eq_top incseq_def)
 
 lemma SUP_sup_continuous_ennreal:
   fixes f :: "ennreal \<Rightarrow> 'a::complete_lattice"
   assumes f: "sup_continuous f" and "I \<noteq> {}"
   shows "(SUP i\<in>I. f (g i)) = f (SUP i\<in>I. g i)"
 proof (rule antisym)
   show "(SUP i\<in>I. f (g i)) \<le> f (SUP i\<in>I. g i)"
     by (rule mono_SUP[OF sup_continuous_mono[OF f]])
   from ennreal_Sup_countable_SUP[of "g`I"] \<open>I \<noteq> {}\<close>
   obtain M :: "nat \<Rightarrow> ennreal" where "incseq M" and M: "range M \<subseteq> g ` I" and eq: "(SUP i \<in> I. g i) = (SUP i. M i)"
     by auto
   have "f (SUP i \<in> I. g i) = (SUP i \<in> range M. f i)"
     unfolding eq sup_continuousD[OF f \<open>mono M\<close>] by (simp add: image_comp)
   also have "\<dots> \<le> (SUP i \<in> I. f (g i))"
     by (insert M, drule SUP_subset_mono) (auto simp add: image_comp)
   finally show "f (SUP i \<in> I. g i) \<le> (SUP i \<in> I. f (g i))" .
 qed
 
 lemma ennreal_suminf_SUP_eq:
   fixes f :: "nat \<Rightarrow> nat \<Rightarrow> ennreal"
   shows "(\<And>i. incseq (\<lambda>n. f n i)) \<Longrightarrow> (\<Sum>i. SUP n. f n i) = (SUP n. \<Sum>i. f n i)"
   apply (rule ennreal_suminf_SUP_eq_directed)
   subgoal for N n j
     by (auto simp: incseq_def intro!:exI[of _ "max n j"])
   done
 
 lemma ennreal_SUP_add_left:
   fixes c :: ennreal
   shows "I \<noteq> {} \<Longrightarrow> (SUP i\<in>I. f i + c) = (SUP i\<in>I. f i) + c"
   apply transfer
   apply (simp add: SUP_ereal_add_left)
   apply (subst (1 2) max.absorb2)
   apply (auto intro: SUP_upper2 add_nonneg_nonneg)
   done
 
 lemma ennreal_SUP_const_minus:
   fixes f :: "'a \<Rightarrow> ennreal"
   shows "I \<noteq> {} \<Longrightarrow> c < top \<Longrightarrow> (INF x\<in>I. c - f x) = c - (SUP x\<in>I. f x)"
   apply (transfer fixing: I)
   unfolding ex_in_conv[symmetric]
   apply (auto simp add: SUP_upper2 sup_absorb2 simp flip: sup_ereal_def)
   apply (subst INF_ereal_minus_right[symmetric])
   apply (auto simp del: sup_ereal_def simp add: sup_INF)
   done
 
 subsection \<open>Approximation lemmas\<close>
 
 lemma INF_approx_ennreal:
   fixes x::ennreal and e::real
   assumes "e > 0"
   assumes INF: "x = (INF i \<in> A. f i)"
   assumes "x \<noteq> \<infinity>"
   shows "\<exists>i \<in> A. f i < x + e"
 proof -
   have "(INF i \<in> A. f i) < x + e"
     unfolding INF[symmetric] using \<open>0<e\<close> \<open>x \<noteq> \<infinity>\<close> by (cases x) auto
   then show ?thesis
     unfolding INF_less_iff .
 qed
 
 lemma SUP_approx_ennreal:
   fixes x::ennreal and e::real
   assumes "e > 0" "A \<noteq> {}"
   assumes SUP: "x = (SUP i \<in> A. f i)"
   assumes "x \<noteq> \<infinity>"
   shows "\<exists>i \<in> A. x < f i + e"
 proof -
   have "x < x + e"
     using \<open>0<e\<close> \<open>x \<noteq> \<infinity>\<close> by (cases x) auto
   also have "x + e = (SUP i \<in> A. f i + e)"
     unfolding SUP ennreal_SUP_add_left[OF \<open>A \<noteq> {}\<close>] ..
   finally show ?thesis
     unfolding less_SUP_iff .
 qed
 
 lemma ennreal_approx_SUP:
   fixes x::ennreal
   assumes f_bound: "\<And>i. i \<in> A \<Longrightarrow> f i \<le> x"
   assumes approx: "\<And>e. (e::real) > 0 \<Longrightarrow> \<exists>i \<in> A. x \<le> f i + e"
   shows "x = (SUP i \<in> A. f i)"
 proof (rule antisym)
   show "x \<le> (SUP i\<in>A. f i)"
   proof (rule ennreal_le_epsilon)
     fix e :: real assume "0 < e"
-    from approx[OF this] guess i ..
-    then have "x \<le> f i + e"
+    from approx[OF this] obtain i where "i \<in> A" and *: "x \<le> f i + ennreal e"
+      by blast
+    from * have "x \<le> f i + e"
       by simp
     also have "\<dots> \<le> (SUP i\<in>A. f i) + e"
       by (intro add_mono \<open>i \<in> A\<close> SUP_upper order_refl)
     finally show "x \<le> (SUP i\<in>A. f i) + e" .
   qed
 qed (intro SUP_least f_bound)
 
 lemma ennreal_approx_INF:
   fixes x::ennreal
   assumes f_bound: "\<And>i. i \<in> A \<Longrightarrow> x \<le> f i"
   assumes approx: "\<And>e. (e::real) > 0 \<Longrightarrow> \<exists>i \<in> A. f i \<le> x + e"
   shows "x = (INF i \<in> A. f i)"
 proof (rule antisym)
   show "(INF i\<in>A. f i) \<le> x"
   proof (rule ennreal_le_epsilon)
     fix e :: real assume "0 < e"
-    from approx[OF this] guess i .. note i = this
+    from approx[OF this] obtain i where "i\<in>A" "f i \<le> x + ennreal e"
+      by blast
     then have "(INF i\<in>A. f i) \<le> f i"
       by (intro INF_lower)
     also have "\<dots> \<le> x + e"
       by fact
     finally show "(INF i\<in>A. f i) \<le> x + e" .
   qed
 qed (intro INF_greatest f_bound)
 
 lemma ennreal_approx_unit:
   "(\<And>a::ennreal. 0 < a \<Longrightarrow> a < 1 \<Longrightarrow> a * z \<le> y) \<Longrightarrow> z \<le> y"
   apply (subst SUP_mult_right_ennreal[of "\<lambda>x. x" "{0 <..< 1}" z, simplified])
   apply (auto intro: SUP_least)
   done
 
 lemma suminf_ennreal2:
   "(\<And>i. 0 \<le> f i) \<Longrightarrow> summable f \<Longrightarrow> (\<Sum>i. ennreal (f i)) = ennreal (\<Sum>i. f i)"
   using suminf_ennreal_eq by blast
 
 lemma less_top_ennreal: "x < top \<longleftrightarrow> (\<exists>r\<ge>0. x = ennreal r)"
   by (cases x) auto
 
 lemma enn2real_less_iff[simp]: "x < top \<Longrightarrow> enn2real x < c \<longleftrightarrow> x < c"
   using ennreal_less_iff less_top_ennreal by auto
 
 lemma enn2real_le_iff[simp]: "\<lbrakk>x < top; c > 0\<rbrakk> \<Longrightarrow> enn2real x \<le> c \<longleftrightarrow> x \<le> c"
   by (cases x) auto
 
 lemma enn2real_less:
   assumes "enn2real e < r" "e \<noteq> top" shows "e < ennreal r"
   using enn2real_less_iff assms top.not_eq_extremum by blast
 
 lemma enn2real_le:
   assumes "enn2real e \<le> r" "e \<noteq> top" shows "e \<le> ennreal r"
   by (metis assms enn2real_less ennreal_enn2real_if eq_iff less_le)
 
 lemma tendsto_top_iff_ennreal:
   fixes f :: "'a \<Rightarrow> ennreal"
   shows "(f \<longlongrightarrow> top) F \<longleftrightarrow> (\<forall>l\<ge>0. eventually (\<lambda>x. ennreal l < f x) F)"
   by (auto simp: less_top_ennreal order_tendsto_iff )
 
 lemma ennreal_tendsto_top_eq_at_top:
   "((\<lambda>z. ennreal (f z)) \<longlongrightarrow> top) F \<longleftrightarrow> (LIM z F. f z :> at_top)"
   unfolding filterlim_at_top_dense tendsto_top_iff_ennreal
   apply (auto simp: ennreal_less_iff)
   subgoal for y
     by (auto elim!: eventually_mono allE[of _ "max 0 y"])
   done
 
 lemma tendsto_0_if_Limsup_eq_0_ennreal:
   fixes f :: "_ \<Rightarrow> ennreal"
   shows "Limsup F f = 0 \<Longrightarrow> (f \<longlongrightarrow> 0) F"
   using Liminf_le_Limsup[of F f] tendsto_iff_Liminf_eq_Limsup[of F f 0]
   by (cases "F = bot") auto
 
 lemma diff_le_self_ennreal[simp]: "a - b \<le> (a::ennreal)"
   by (cases a b rule: ennreal2_cases) (auto simp: ennreal_minus)
 
 lemma ennreal_ineq_diff_add: "b \<le> a \<Longrightarrow> a = b + (a - b::ennreal)"
   by transfer (auto simp: ereal_diff_positive max.absorb2 ereal_ineq_diff_add)
 
 lemma ennreal_mult_strict_left_mono: "(a::ennreal) < c \<Longrightarrow> 0 < b \<Longrightarrow> b < top \<Longrightarrow> b * a < b * c"
   by transfer (auto intro!: ereal_mult_strict_left_mono)
 
 lemma ennreal_between: "0 < e \<Longrightarrow> 0 < x \<Longrightarrow> x < top \<Longrightarrow> x - e < (x::ennreal)"
   by transfer (auto intro!: ereal_between)
 
 lemma minus_less_iff_ennreal: "b < top \<Longrightarrow> b \<le> a \<Longrightarrow> a - b < c \<longleftrightarrow> a < c + (b::ennreal)"
   by transfer
      (auto simp: top_ereal_def ereal_minus_less le_less)
 
 lemma tendsto_zero_ennreal:
   assumes ev: "\<And>r. 0 < r \<Longrightarrow> \<forall>\<^sub>F x in F. f x < ennreal r"
   shows "(f \<longlongrightarrow> 0) F"
 proof (rule order_tendstoI)
   fix e::ennreal assume "e > 0"
   obtain e'::real where "e' > 0" "ennreal e' < e"
     using \<open>0 < e\<close> dense[of 0 "if e = top then 1 else (enn2real e)"]
     by (cases e) (auto simp: ennreal_less_iff)
   from ev[OF \<open>e' > 0\<close>] show "\<forall>\<^sub>F x in F. f x < e"
     by eventually_elim (insert \<open>ennreal e' < e\<close>, auto)
 qed simp
 
 lifting_update ennreal.lifting
 lifting_forget ennreal.lifting
 
 
 subsection \<open>\<^typ>\<open>ennreal\<close> theorems\<close>
 
 lemma neq_top_trans: fixes x y :: ennreal shows "\<lbrakk> y \<noteq> top; x \<le> y \<rbrakk> \<Longrightarrow> x \<noteq> top"
   by (auto simp: top_unique)
 
 lemma diff_diff_ennreal: fixes a b :: ennreal shows "a \<le> b \<Longrightarrow> b \<noteq> \<infinity> \<Longrightarrow> b - (b - a) = a"
   by (cases a b rule: ennreal2_cases) (auto simp: ennreal_minus top_unique)
 
 lemma ennreal_less_one_iff[simp]: "ennreal x < 1 \<longleftrightarrow> x < 1"
   by (cases "0 \<le> x") (auto simp: ennreal_neg ennreal_less_iff simp flip: ennreal_1)
 
 lemma SUP_const_minus_ennreal:
   fixes f :: "'a \<Rightarrow> ennreal" shows "I \<noteq> {} \<Longrightarrow> (SUP x\<in>I. c - f x) = c - (INF x\<in>I. f x)"
   including ennreal.lifting
   by (transfer fixing: I)
      (simp add: SUP_sup_distrib[symmetric] SUP_ereal_minus_right
            flip: sup_ereal_def)
 
 lemma zero_minus_ennreal[simp]: "0 - (a::ennreal) = 0"
   including ennreal.lifting
   by transfer (simp split: split_max)
 
 lemma diff_diff_commute_ennreal:
   fixes a b c :: ennreal shows "a - b - c = a - c - b"
   by (cases a b c rule: ennreal3_cases) (simp_all add: ennreal_minus field_simps)
 
 lemma diff_gr0_ennreal: "b < (a::ennreal) \<Longrightarrow> 0 < a - b"
   including ennreal.lifting by transfer (auto simp: ereal_diff_gr0 ereal_diff_positive split: split_max)
 
 lemma divide_le_posI_ennreal:
   fixes x y z :: ennreal
   shows "x > 0 \<Longrightarrow> z \<le> x * y \<Longrightarrow> z / x \<le> y"
   by (cases x y z rule: ennreal3_cases)
      (auto simp: divide_ennreal ennreal_mult[symmetric] field_simps top_unique)
 
 lemma add_diff_eq_ennreal:
   fixes x y z :: ennreal
   shows "z \<le> y \<Longrightarrow> x + (y - z) = x + y - z"
   including ennreal.lifting
   by transfer
      (insert add_mono[of "0::ereal"], auto simp add: ereal_diff_positive max.absorb2 add_diff_eq_ereal)
 
 lemma add_diff_inverse_ennreal:
   fixes x y :: ennreal shows "x \<le> y \<Longrightarrow> x + (y - x) = y"
   by (cases x) (simp_all add: top_unique add_diff_eq_ennreal)
 
 lemma add_diff_eq_iff_ennreal[simp]:
   fixes x y :: ennreal shows "x + (y - x) = y \<longleftrightarrow> x \<le> y"
 proof
   assume *: "x + (y - x) = y" show "x \<le> y"
     by (subst *[symmetric]) simp
 qed (simp add: add_diff_inverse_ennreal)
 
 lemma add_diff_le_ennreal: "a + b - c \<le> a + (b - c::ennreal)"
   apply (cases a b c rule: ennreal3_cases)
   subgoal for a' b' c'
     by (cases "0 \<le> b' - c'") (simp_all add: ennreal_minus top_add ennreal_neg flip: ennreal_plus)
   apply (simp_all add: top_add flip: ennreal_plus)
   done
 
 lemma diff_eq_0_ennreal: "a < top \<Longrightarrow> a \<le> b \<Longrightarrow> a - b = (0::ennreal)"
   using ennreal_minus_pos_iff gr_zeroI not_less by blast
 
 lemma diff_diff_ennreal': fixes x y z :: ennreal shows "z \<le> y \<Longrightarrow> y - z \<le> x \<Longrightarrow> x - (y - z) = x + z - y"
   by (cases x; cases y; cases z)
      (auto simp add: top_add add_top minus_top_ennreal ennreal_minus top_unique
            simp flip: ennreal_plus)
 
 lemma diff_diff_ennreal'': fixes x y z :: ennreal
   shows "z \<le> y \<Longrightarrow> x - (y - z) = (if y - z \<le> x then x + z - y else 0)"
   by (cases x; cases y; cases z)
      (auto simp add: top_add add_top minus_top_ennreal ennreal_minus top_unique ennreal_neg
            simp flip: ennreal_plus)
 
 lemma power_less_top_ennreal: fixes x :: ennreal shows "x ^ n < top \<longleftrightarrow> x < top \<or> n = 0"
   using power_eq_top_ennreal[of x n] by (auto simp: less_top)
 
 lemma ennreal_divide_times: "(a / b) * c = a * (c / b :: ennreal)"
   by (simp add: mult.commute ennreal_times_divide)
 
 lemma diff_less_top_ennreal: "a - b < top \<longleftrightarrow>  a < (top :: ennreal)"
   by (cases a; cases b) (auto simp: ennreal_minus)
 
 lemma divide_less_ennreal: "b \<noteq> 0 \<Longrightarrow> b < top \<Longrightarrow> a / b < c \<longleftrightarrow> a < (c * b :: ennreal)"
   by (cases a; cases b; cases c)
      (auto simp: divide_ennreal ennreal_mult[symmetric] ennreal_less_iff field_simps ennreal_top_mult ennreal_top_divide)
 
 lemma one_less_numeral[simp]: "1 < (numeral n::ennreal) \<longleftrightarrow> (num.One < n)"
   by (simp flip: ennreal_1 ennreal_numeral add: ennreal_less_iff)
 
 lemma divide_eq_1_ennreal: "a / b = (1::ennreal) \<longleftrightarrow> (b \<noteq> top \<and> b \<noteq> 0 \<and> b = a)"
   by (cases a ; cases b; cases "b = 0") (auto simp: ennreal_top_divide divide_ennreal split: if_split_asm)
 
 lemma ennreal_mult_cancel_left: "(a * b = a * c) = (a = top \<and> b \<noteq> 0 \<and> c \<noteq> 0 \<or> a = 0 \<or> b = (c::ennreal))"
   by (cases a; cases b; cases c) (auto simp: ennreal_mult[symmetric] ennreal_mult_top ennreal_top_mult)
 
 lemma ennreal_minus_if: "ennreal a - ennreal b = ennreal (if 0 \<le> b then (if b \<le> a then a - b else 0) else a)"
   by (auto simp: ennreal_minus ennreal_neg)
 
 lemma ennreal_plus_if: "ennreal a + ennreal b = ennreal (if 0 \<le> a then (if 0 \<le> b then a + b else a) else b)"
   by (auto simp: ennreal_neg)
 
 lemma power_le_one_iff: "0 \<le> (a::real) \<Longrightarrow> a ^ n \<le> 1 \<longleftrightarrow> (n = 0 \<or> a \<le> 1)"
   by (metis (mono_tags, opaque_lifting) le_less neq0_conv not_le one_le_power power_0 power_eq_imp_eq_base power_le_one zero_le_one)
 
 lemma ennreal_diff_le_mono_left: "a \<le> b \<Longrightarrow> a - c \<le> (b::ennreal)"
   using ennreal_mono_minus[of 0 c a, THEN order_trans, of b] by simp
 
 lemma ennreal_minus_le_iff: "a - b \<le> c \<longleftrightarrow> (a \<le> b + (c::ennreal) \<and> (a = top \<and> b = top \<longrightarrow> c = top))"
   by (cases a; cases b; cases c)
      (auto simp: top_unique top_add add_top ennreal_minus simp flip: ennreal_plus)
 
 lemma ennreal_le_minus_iff: "a \<le> b - c \<longleftrightarrow> (a + c \<le> (b::ennreal) \<or> (a = 0 \<and> b \<le> c))"
   by (cases a; cases b; cases c)
      (auto simp: top_unique top_add add_top ennreal_minus ennreal_le_iff2
            simp flip: ennreal_plus)
 
 lemma diff_add_eq_diff_diff_swap_ennreal: "x - (y + z :: ennreal) = x - y - z"
   by (cases x; cases y; cases z)
      (auto simp: ennreal_minus_if add_top top_add simp flip: ennreal_plus)
 
 lemma diff_add_assoc2_ennreal: "b \<le> a \<Longrightarrow> (a - b + c::ennreal) = a + c - b"
   by (cases a; cases b; cases c)
      (auto simp add: ennreal_minus_if ennreal_plus_if add_top top_add top_unique simp del: ennreal_plus)
 
 lemma diff_gt_0_iff_gt_ennreal: "0 < a - b \<longleftrightarrow> (a = top \<and> b = top \<or> b < (a::ennreal))"
   by (cases a; cases b) (auto simp: ennreal_minus_if ennreal_less_iff)
 
 lemma diff_eq_0_iff_ennreal: "(a - b::ennreal) = 0 \<longleftrightarrow> (a < top \<and> a \<le> b)"
   by (cases a) (auto simp: ennreal_minus_eq_0 diff_eq_0_ennreal)
 
 lemma add_diff_self_ennreal: "a + (b - a::ennreal) = (if a \<le> b then b else a)"
   by (auto simp: diff_eq_0_iff_ennreal less_top)
 
 lemma diff_add_self_ennreal: "(b - a + a::ennreal) = (if a \<le> b then b else a)"
   by (auto simp: diff_add_cancel_ennreal diff_eq_0_iff_ennreal less_top)
 
 lemma ennreal_minus_cancel_iff:
   fixes a b c :: ennreal
   shows "a - b = a - c \<longleftrightarrow> (b = c \<or> (a \<le> b \<and> a \<le> c) \<or> a = top)"
   by (cases a; cases b; cases c) (auto simp: ennreal_minus_if)
 
 text \<open>The next lemma is wrong for $a = top$, for $b = c = 1$ for instance.\<close>
 
 lemma ennreal_right_diff_distrib:
   fixes a b c :: ennreal
   assumes "a \<noteq> top"
   shows "a * (b - c) = a * b - a * c"
   apply (cases a; cases b; cases c)
          apply (use assms in \<open>auto simp add: ennreal_mult_top ennreal_minus ennreal_mult' [symmetric]\<close>)
   apply (simp add: algebra_simps)
   done
 
 lemma SUP_diff_ennreal:
   "c < top \<Longrightarrow> (SUP i\<in>I. f i - c :: ennreal) = (SUP i\<in>I. f i) - c"
   by (auto intro!: SUP_eqI ennreal_minus_mono SUP_least intro: SUP_upper
            simp: ennreal_minus_cancel_iff ennreal_minus_le_iff less_top[symmetric])
 
 lemma ennreal_SUP_add_right:
   fixes c :: ennreal shows "I \<noteq> {} \<Longrightarrow> c + (SUP i\<in>I. f i) = (SUP i\<in>I. c + f i)"
   using ennreal_SUP_add_left[of I f c] by (simp add: add.commute)
 
 lemma SUP_add_directed_ennreal:
   fixes f g :: "_ \<Rightarrow> ennreal"
   assumes directed: "\<And>i j. i \<in> I \<Longrightarrow> j \<in> I \<Longrightarrow> \<exists>k\<in>I. f i + g j \<le> f k + g k"
   shows "(SUP i\<in>I. f i + g i) = (SUP i\<in>I. f i) + (SUP i\<in>I. g i)"
 proof cases
   assume "I = {}" then show ?thesis
     by (simp add: bot_ereal_def)
 next
   assume "I \<noteq> {}"
   show ?thesis
   proof (rule antisym)
     show "(SUP i\<in>I. f i + g i) \<le> (SUP i\<in>I. f i) + (SUP i\<in>I. g i)"
       by (rule SUP_least; intro add_mono SUP_upper)
   next
     have "(SUP i\<in>I. f i) + (SUP i\<in>I. g i) = (SUP i\<in>I. f i + (SUP i\<in>I. g i))"
       by (intro ennreal_SUP_add_left[symmetric] \<open>I \<noteq> {}\<close>)
     also have "\<dots> = (SUP i\<in>I. (SUP j\<in>I. f i + g j))"
       using \<open>I \<noteq> {}\<close> by (simp add: ennreal_SUP_add_right)
     also have "\<dots> \<le> (SUP i\<in>I. f i + g i)"
       using directed by (intro SUP_least) (blast intro: SUP_upper2)
     finally show "(SUP i\<in>I. f i) + (SUP i\<in>I. g i) \<le> (SUP i\<in>I. f i + g i)" .
   qed
 qed
 
 lemma enn2real_eq_0_iff: "enn2real x = 0 \<longleftrightarrow> x = 0 \<or> x = top"
   by (cases x) auto
 
 lemma continuous_on_diff_ennreal:
   "continuous_on A f \<Longrightarrow> continuous_on A g \<Longrightarrow> (\<And>x. x \<in> A \<Longrightarrow> f x \<noteq> top) \<Longrightarrow> (\<And>x. x \<in> A \<Longrightarrow> g x \<noteq> top) \<Longrightarrow> continuous_on A (\<lambda>z. f z - g z::ennreal)"
   including ennreal.lifting
 proof (transfer fixing: A, simp add: top_ereal_def)
   fix f g :: "'a \<Rightarrow> ereal" assume "\<forall>x. 0 \<le> f x" "\<forall>x. 0 \<le> g x" "continuous_on A f" "continuous_on A g"
   moreover assume "f x \<noteq> \<infinity>" "g x \<noteq> \<infinity>" if "x \<in> A" for x
   ultimately show "continuous_on A (\<lambda>z. max 0 (f z - g z))"
     by (intro continuous_on_max continuous_on_const continuous_on_diff_ereal) auto
 qed
 
 lemma tendsto_diff_ennreal:
   "(f \<longlongrightarrow> x) F \<Longrightarrow> (g \<longlongrightarrow> y) F \<Longrightarrow> x \<noteq> top \<Longrightarrow> y \<noteq> top \<Longrightarrow> ((\<lambda>z. f z - g z::ennreal) \<longlongrightarrow> x - y) F"
   using continuous_on_tendsto_compose[where f="\<lambda>x. fst x - snd x::ennreal" and s="{(x, y). x \<noteq> top \<and> y \<noteq> top}" and g="\<lambda>x. (f x, g x)" and l="(x, y)" and F="F",
     OF continuous_on_diff_ennreal]
   by (auto simp: tendsto_Pair eventually_conj_iff less_top order_tendstoD continuous_on_fst continuous_on_snd continuous_on_id)
 
 declare lim_real_of_ereal [tendsto_intros]
 
 lemma tendsto_enn2real [tendsto_intros]:
   assumes "(u \<longlongrightarrow> ennreal l) F" "l \<ge> 0"
   shows "((\<lambda>n. enn2real (u n)) \<longlongrightarrow> l) F"
   unfolding enn2real_def
   by (metis assms enn2ereal_ennreal lim_real_of_ereal tendsto_enn2erealI)
 
 end
diff --git a/src/HOL/Library/Extended_Real.thy b/src/HOL/Library/Extended_Real.thy
--- a/src/HOL/Library/Extended_Real.thy
+++ b/src/HOL/Library/Extended_Real.thy
@@ -1,4200 +1,4200 @@
 (*  Title:      HOL/Library/Extended_Real.thy
     Author:     Johannes Hölzl, TU München
     Author:     Robert Himmelmann, TU München
     Author:     Armin Heller, TU München
     Author:     Bogdan Grechuk, University of Edinburgh
     Author:     Manuel Eberl, TU München
 *)
 
 section \<open>Extended real number line\<close>
 
 theory Extended_Real
 imports Complex_Main Extended_Nat Liminf_Limsup
 begin
 
 text \<open>
   This should be part of \<^theory>\<open>HOL-Library.Extended_Nat\<close> or \<^theory>\<open>HOL-Library.Order_Continuity\<close>, but then the AFP-entry \<open>Jinja_Thread\<close> fails, as it does overload
   certain named from \<^theory>\<open>Complex_Main\<close>.
 \<close>
 
 lemma incseq_sumI2:
   fixes f :: "'i \<Rightarrow> nat \<Rightarrow> 'a::ordered_comm_monoid_add"
   shows "(\<And>n. n \<in> A \<Longrightarrow> mono (f n)) \<Longrightarrow> mono (\<lambda>i. \<Sum>n\<in>A. f n i)"
   unfolding incseq_def by (auto intro: sum_mono)
 
 lemma incseq_sumI:
   fixes f :: "nat \<Rightarrow> 'a::ordered_comm_monoid_add"
   assumes "\<And>i. 0 \<le> f i"
   shows "incseq (\<lambda>i. sum f {..< i})"
 proof (intro incseq_SucI)
   fix n
   have "sum f {..< n} + 0 \<le> sum f {..<n} + f n"
     using assms by (rule add_left_mono)
   then show "sum f {..< n} \<le> sum f {..< Suc n}"
     by auto
 qed
 
 lemma continuous_at_left_imp_sup_continuous:
   fixes f :: "'a::{complete_linorder, linorder_topology} \<Rightarrow> 'b::{complete_linorder, linorder_topology}"
   assumes "mono f" "\<And>x. continuous (at_left x) f"
   shows "sup_continuous f"
   unfolding sup_continuous_def
 proof safe
   fix M :: "nat \<Rightarrow> 'a" assume "incseq M" then show "f (SUP i. M i) = (SUP i. f (M i))"
     using continuous_at_Sup_mono [OF assms, of "range M"] by (simp add: image_comp)
 qed
 
 lemma sup_continuous_at_left:
   fixes f :: "'a::{complete_linorder, linorder_topology, first_countable_topology} \<Rightarrow>
     'b::{complete_linorder, linorder_topology}"
   assumes f: "sup_continuous f"
   shows "continuous (at_left x) f"
 proof cases
   assume "x = bot" then show ?thesis
     by (simp add: trivial_limit_at_left_bot)
 next
   assume x: "x \<noteq> bot"
   show ?thesis
     unfolding continuous_within
   proof (intro tendsto_at_left_sequentially[of bot])
     fix S :: "nat \<Rightarrow> 'a" assume S: "incseq S" and S_x: "S \<longlonglongrightarrow> x"
     from S_x have x_eq: "x = (SUP i. S i)"
       by (rule LIMSEQ_unique) (intro LIMSEQ_SUP S)
     show "(\<lambda>n. f (S n)) \<longlonglongrightarrow> f x"
       unfolding x_eq sup_continuousD[OF f S]
       using S sup_continuous_mono[OF f] by (intro LIMSEQ_SUP) (auto simp: mono_def)
   qed (insert x, auto simp: bot_less)
 qed
 
 lemma sup_continuous_iff_at_left:
   fixes f :: "'a::{complete_linorder, linorder_topology, first_countable_topology} \<Rightarrow>
     'b::{complete_linorder, linorder_topology}"
   shows "sup_continuous f \<longleftrightarrow> (\<forall>x. continuous (at_left x) f) \<and> mono f"
   using sup_continuous_at_left[of f] continuous_at_left_imp_sup_continuous[of f]
     sup_continuous_mono[of f] by auto
 
 lemma continuous_at_right_imp_inf_continuous:
   fixes f :: "'a::{complete_linorder, linorder_topology} \<Rightarrow> 'b::{complete_linorder, linorder_topology}"
   assumes "mono f" "\<And>x. continuous (at_right x) f"
   shows "inf_continuous f"
   unfolding inf_continuous_def
 proof safe
   fix M :: "nat \<Rightarrow> 'a" assume "decseq M" then show "f (INF i. M i) = (INF i. f (M i))"
     using continuous_at_Inf_mono [OF assms, of "range M"] by (simp add: image_comp)
 qed
 
 lemma inf_continuous_at_right:
   fixes f :: "'a::{complete_linorder, linorder_topology, first_countable_topology} \<Rightarrow>
     'b::{complete_linorder, linorder_topology}"
   assumes f: "inf_continuous f"
   shows "continuous (at_right x) f"
 proof cases
   assume "x = top" then show ?thesis
     by (simp add: trivial_limit_at_right_top)
 next
   assume x: "x \<noteq> top"
   show ?thesis
     unfolding continuous_within
   proof (intro tendsto_at_right_sequentially[of _ top])
     fix S :: "nat \<Rightarrow> 'a" assume S: "decseq S" and S_x: "S \<longlonglongrightarrow> x"
     from S_x have x_eq: "x = (INF i. S i)"
       by (rule LIMSEQ_unique) (intro LIMSEQ_INF S)
     show "(\<lambda>n. f (S n)) \<longlonglongrightarrow> f x"
       unfolding x_eq inf_continuousD[OF f S]
       using S inf_continuous_mono[OF f] by (intro LIMSEQ_INF) (auto simp: mono_def antimono_def)
   qed (insert x, auto simp: less_top)
 qed
 
 lemma inf_continuous_iff_at_right:
   fixes f :: "'a::{complete_linorder, linorder_topology, first_countable_topology} \<Rightarrow>
     'b::{complete_linorder, linorder_topology}"
   shows "inf_continuous f \<longleftrightarrow> (\<forall>x. continuous (at_right x) f) \<and> mono f"
   using inf_continuous_at_right[of f] continuous_at_right_imp_inf_continuous[of f]
     inf_continuous_mono[of f] by auto
 
 instantiation enat :: linorder_topology
 begin
 
 definition open_enat :: "enat set \<Rightarrow> bool" where
   "open_enat = generate_topology (range lessThan \<union> range greaterThan)"
 
 instance
   proof qed (rule open_enat_def)
 
 end
 
 lemma open_enat: "open {enat n}"
 proof (cases n)
   case 0
   then have "{enat n} = {..< eSuc 0}"
     by (auto simp: enat_0)
   then show ?thesis
     by simp
 next
   case (Suc n')
   then have "{enat n} = {enat n' <..< enat (Suc n)}"
     using enat_iless by (fastforce simp: set_eq_iff)
   then show ?thesis
     by simp
 qed
 
 lemma open_enat_iff:
   fixes A :: "enat set"
   shows "open A \<longleftrightarrow> (\<infinity> \<in> A \<longrightarrow> (\<exists>n::nat. {n <..} \<subseteq> A))"
 proof safe
   assume "\<infinity> \<notin> A"
   then have "A = (\<Union>n\<in>{n. enat n \<in> A}. {enat n})"
     by (simp add: set_eq_iff) (metis not_enat_eq)
   moreover have "open \<dots>"
     by (auto intro: open_enat)
   ultimately show "open A"
     by simp
 next
   fix n assume "{enat n <..} \<subseteq> A"
   then have "A = (\<Union>n\<in>{n. enat n \<in> A}. {enat n}) \<union> {enat n <..}"
     using enat_ile leI by (simp add: set_eq_iff) blast
   moreover have "open \<dots>"
     by (intro open_Un open_UN ballI open_enat open_greaterThan)
   ultimately show "open A"
     by simp
 next
   assume "open A" "\<infinity> \<in> A"
   then have "generate_topology (range lessThan \<union> range greaterThan) A" "\<infinity> \<in> A"
     unfolding open_enat_def by auto
   then show "\<exists>n::nat. {n <..} \<subseteq> A"
   proof induction
     case (Int A B)
     then obtain n m where "{enat n<..} \<subseteq> A" "{enat m<..} \<subseteq> B"
       by auto
     then have "{enat (max n m) <..} \<subseteq> A \<inter> B"
       by (auto simp add: subset_eq Ball_def max_def simp flip: enat_ord_code(1))
     then show ?case
       by auto
   next
     case (UN K)
     then obtain k where "k \<in> K" "\<infinity> \<in> k"
       by auto
     with UN.IH[OF this] show ?case
       by auto
   qed auto
 qed
 
 lemma nhds_enat: "nhds x = (if x = \<infinity> then INF i. principal {enat i..} else principal {x})"
 proof auto
   show "nhds \<infinity> = (INF i. principal {enat i..})"
   proof (rule antisym)
     show "nhds \<infinity> \<le> (INF i. principal {enat i..})"
       unfolding nhds_def
       using Ioi_le_Ico by (intro INF_greatest INF_lower) (auto simp add: open_enat_iff)
     show "(INF i. principal {enat i..}) \<le> nhds \<infinity>"
       unfolding nhds_def
       by (intro INF_greatest) (force intro: INF_lower2[of "Suc _"] simp add: open_enat_iff Suc_ile_eq)
   qed
   show "nhds (enat i) = principal {enat i}" for i
     by (simp add: nhds_discrete_open open_enat)
 qed
 
 instance enat :: topological_comm_monoid_add
 proof
   have [simp]: "enat i \<le> aa \<Longrightarrow> enat i \<le> aa + ba" for aa ba i
     by (rule order_trans[OF _ add_mono[of aa aa 0 ba]]) auto
   then have [simp]: "enat i \<le> ba \<Longrightarrow> enat i \<le> aa + ba" for aa ba i
     by (metis add.commute)
   fix a b :: enat show "((\<lambda>x. fst x + snd x) \<longlongrightarrow> a + b) (nhds a \<times>\<^sub>F nhds b)"
     apply (auto simp: nhds_enat filterlim_INF prod_filter_INF1 prod_filter_INF2
                       filterlim_principal principal_prod_principal eventually_principal)
     subgoal for i
       by (auto intro!: eventually_INF1[of i] simp: eventually_principal)
     subgoal for j i
       by (auto intro!: eventually_INF1[of i] simp: eventually_principal)
     subgoal for j i
       by (auto intro!: eventually_INF1[of i] simp: eventually_principal)
     done
 qed
 
 text \<open>
   For more lemmas about the extended real numbers see
   \<^file>\<open>~~/src/HOL/Analysis/Extended_Real_Limits.thy\<close>.
 \<close>
 
 subsection \<open>Definition and basic properties\<close>
 
 datatype ereal = ereal real | PInfty | MInfty
 
 lemma ereal_cong: "x = y \<Longrightarrow> ereal x = ereal y" by simp
 
 instantiation ereal :: uminus
 begin
 
 fun uminus_ereal where
   "- (ereal r) = ereal (- r)"
 | "- PInfty = MInfty"
 | "- MInfty = PInfty"
 
 instance ..
 
 end
 
 instantiation ereal :: infinity
 begin
 
 definition "(\<infinity>::ereal) = PInfty"
 instance ..
 
 end
 
 declare [[coercion "ereal :: real \<Rightarrow> ereal"]]
 
 lemma ereal_uminus_uminus[simp]:
   fixes a :: ereal
   shows "- (- a) = a"
   by (cases a) simp_all
 
 lemma
   shows PInfty_eq_infinity[simp]: "PInfty = \<infinity>"
     and MInfty_eq_minfinity[simp]: "MInfty = - \<infinity>"
     and MInfty_neq_PInfty[simp]: "\<infinity> \<noteq> - (\<infinity>::ereal)" "- \<infinity> \<noteq> (\<infinity>::ereal)"
     and MInfty_neq_ereal[simp]: "ereal r \<noteq> - \<infinity>" "- \<infinity> \<noteq> ereal r"
     and PInfty_neq_ereal[simp]: "ereal r \<noteq> \<infinity>" "\<infinity> \<noteq> ereal r"
     and PInfty_cases[simp]: "(case \<infinity> of ereal r \<Rightarrow> f r | PInfty \<Rightarrow> y | MInfty \<Rightarrow> z) = y"
     and MInfty_cases[simp]: "(case - \<infinity> of ereal r \<Rightarrow> f r | PInfty \<Rightarrow> y | MInfty \<Rightarrow> z) = z"
   by (simp_all add: infinity_ereal_def)
 
 declare
   PInfty_eq_infinity[code_post]
   MInfty_eq_minfinity[code_post]
 
 lemma [code_unfold]:
   "\<infinity> = PInfty"
   "- PInfty = MInfty"
   by simp_all
 
 lemma inj_ereal[simp]: "inj_on ereal A"
   unfolding inj_on_def by auto
 
 lemma ereal_cases[cases type: ereal]:
   obtains (real) r where "x = ereal r"
     | (PInf) "x = \<infinity>"
     | (MInf) "x = -\<infinity>"
   by (cases x) auto
 
 lemmas ereal2_cases = ereal_cases[case_product ereal_cases]
 lemmas ereal3_cases = ereal2_cases[case_product ereal_cases]
 
 lemma ereal_all_split: "\<And>P. (\<forall>x::ereal. P x) \<longleftrightarrow> P \<infinity> \<and> (\<forall>x. P (ereal x)) \<and> P (-\<infinity>)"
   by (metis ereal_cases)
 
 lemma ereal_ex_split: "\<And>P. (\<exists>x::ereal. P x) \<longleftrightarrow> P \<infinity> \<or> (\<exists>x. P (ereal x)) \<or> P (-\<infinity>)"
   by (metis ereal_cases)
 
 lemma ereal_uminus_eq_iff[simp]:
   fixes a b :: ereal
   shows "-a = -b \<longleftrightarrow> a = b"
   by (cases rule: ereal2_cases[of a b]) simp_all
 
 function real_of_ereal :: "ereal \<Rightarrow> real" where
   "real_of_ereal (ereal r) = r"
 | "real_of_ereal \<infinity> = 0"
 | "real_of_ereal (-\<infinity>) = 0"
   by (auto intro: ereal_cases)
 termination by standard (rule wf_empty)
 
 lemma real_of_ereal[simp]:
   "real_of_ereal (- x :: ereal) = - (real_of_ereal x)"
   by (cases x) simp_all
 
 lemma range_ereal[simp]: "range ereal = UNIV - {\<infinity>, -\<infinity>}"
 proof safe
   fix x
   assume "x \<notin> range ereal" "x \<noteq> \<infinity>"
   then show "x = -\<infinity>"
     by (cases x) auto
 qed auto
 
 lemma ereal_range_uminus[simp]: "range uminus = (UNIV::ereal set)"
 proof safe
   fix x :: ereal
   show "x \<in> range uminus"
     by (intro image_eqI[of _ _ "-x"]) auto
 qed auto
 
 instantiation ereal :: abs
 begin
 
 function abs_ereal where
   "\<bar>ereal r\<bar> = ereal \<bar>r\<bar>"
 | "\<bar>-\<infinity>\<bar> = (\<infinity>::ereal)"
 | "\<bar>\<infinity>\<bar> = (\<infinity>::ereal)"
 by (auto intro: ereal_cases)
 termination proof qed (rule wf_empty)
 
 instance ..
 
 end
 
 lemma abs_eq_infinity_cases[elim!]:
   fixes x :: ereal
   assumes "\<bar>x\<bar> = \<infinity>"
   obtains "x = \<infinity>" | "x = -\<infinity>"
   using assms by (cases x) auto
 
 lemma abs_neq_infinity_cases[elim!]:
   fixes x :: ereal
   assumes "\<bar>x\<bar> \<noteq> \<infinity>"
   obtains r where "x = ereal r"
   using assms by (cases x) auto
 
 lemma abs_ereal_uminus[simp]:
   fixes x :: ereal
   shows "\<bar>- x\<bar> = \<bar>x\<bar>"
   by (cases x) auto
 
 lemma ereal_infinity_cases:
   fixes a :: ereal
   shows "a \<noteq> \<infinity> \<Longrightarrow> a \<noteq> -\<infinity> \<Longrightarrow> \<bar>a\<bar> \<noteq> \<infinity>"
   by auto
 
 subsubsection "Addition"
 
 instantiation ereal :: "{one,comm_monoid_add,zero_neq_one}"
 begin
 
 definition "0 = ereal 0"
 definition "1 = ereal 1"
 
 function plus_ereal where
   "ereal r + ereal p = ereal (r + p)"
 | "\<infinity> + a = (\<infinity>::ereal)"
 | "a + \<infinity> = (\<infinity>::ereal)"
 | "ereal r + -\<infinity> = - \<infinity>"
 | "-\<infinity> + ereal p = -(\<infinity>::ereal)"
 | "-\<infinity> + -\<infinity> = -(\<infinity>::ereal)"
 proof goal_cases
   case prems: (1 P x)
   then obtain a b where "x = (a, b)"
     by (cases x) auto
   with prems show P
    by (cases rule: ereal2_cases[of a b]) auto
 qed auto
 termination by standard (rule wf_empty)
 
 lemma Infty_neq_0[simp]:
   "(\<infinity>::ereal) \<noteq> 0" "0 \<noteq> (\<infinity>::ereal)"
   "-(\<infinity>::ereal) \<noteq> 0" "0 \<noteq> -(\<infinity>::ereal)"
   by (simp_all add: zero_ereal_def)
 
 lemma ereal_eq_0[simp]:
   "ereal r = 0 \<longleftrightarrow> r = 0"
   "0 = ereal r \<longleftrightarrow> r = 0"
   unfolding zero_ereal_def by simp_all
 
 lemma ereal_eq_1[simp]:
   "ereal r = 1 \<longleftrightarrow> r = 1"
   "1 = ereal r \<longleftrightarrow> r = 1"
   unfolding one_ereal_def by simp_all
 
 instance
 proof
   fix a b c :: ereal
   show "0 + a = a"
     by (cases a) (simp_all add: zero_ereal_def)
   show "a + b = b + a"
     by (cases rule: ereal2_cases[of a b]) simp_all
   show "a + b + c = a + (b + c)"
     by (cases rule: ereal3_cases[of a b c]) simp_all
   show "0 \<noteq> (1::ereal)"
     by (simp add: one_ereal_def zero_ereal_def)
 qed
 
 end
 
 lemma ereal_0_plus [simp]: "ereal 0 + x = x"
   and plus_ereal_0 [simp]: "x + ereal 0 = x"
 by(simp_all flip: zero_ereal_def)
 
 instance ereal :: numeral ..
 
 lemma real_of_ereal_0[simp]: "real_of_ereal (0::ereal) = 0"
   unfolding zero_ereal_def by simp
 
 lemma abs_ereal_zero[simp]: "\<bar>0\<bar> = (0::ereal)"
   unfolding zero_ereal_def abs_ereal.simps by simp
 
 lemma ereal_uminus_zero[simp]: "- 0 = (0::ereal)"
   by (simp add: zero_ereal_def)
 
 lemma ereal_uminus_zero_iff[simp]:
   fixes a :: ereal
   shows "-a = 0 \<longleftrightarrow> a = 0"
   by (cases a) simp_all
 
 lemma ereal_plus_eq_PInfty[simp]:
   fixes a b :: ereal
   shows "a + b = \<infinity> \<longleftrightarrow> a = \<infinity> \<or> b = \<infinity>"
   by (cases rule: ereal2_cases[of a b]) auto
 
 lemma ereal_plus_eq_MInfty[simp]:
   fixes a b :: ereal
   shows "a + b = -\<infinity> \<longleftrightarrow> (a = -\<infinity> \<or> b = -\<infinity>) \<and> a \<noteq> \<infinity> \<and> b \<noteq> \<infinity>"
   by (cases rule: ereal2_cases[of a b]) auto
 
 lemma ereal_add_cancel_left:
   fixes a b :: ereal
   assumes "a \<noteq> -\<infinity>"
   shows "a + b = a + c \<longleftrightarrow> a = \<infinity> \<or> b = c"
   using assms by (cases rule: ereal3_cases[of a b c]) auto
 
 lemma ereal_add_cancel_right:
   fixes a b :: ereal
   assumes "a \<noteq> -\<infinity>"
   shows "b + a = c + a \<longleftrightarrow> a = \<infinity> \<or> b = c"
   using assms by (cases rule: ereal3_cases[of a b c]) auto
 
 lemma ereal_real: "ereal (real_of_ereal x) = (if \<bar>x\<bar> = \<infinity> then 0 else x)"
   by (cases x) simp_all
 
 lemma real_of_ereal_add:
   fixes a b :: ereal
   shows "real_of_ereal (a + b) =
     (if (\<bar>a\<bar> = \<infinity>) \<and> (\<bar>b\<bar> = \<infinity>) \<or> (\<bar>a\<bar> \<noteq> \<infinity>) \<and> (\<bar>b\<bar> \<noteq> \<infinity>) then real_of_ereal a + real_of_ereal b else 0)"
   by (cases rule: ereal2_cases[of a b]) auto
 
 
 subsubsection "Linear order on \<^typ>\<open>ereal\<close>"
 
 instantiation ereal :: linorder
 begin
 
 function less_ereal
 where
   "   ereal x < ereal y     \<longleftrightarrow> x < y"
 | "(\<infinity>::ereal) < a           \<longleftrightarrow> False"
 | "         a < -(\<infinity>::ereal) \<longleftrightarrow> False"
 | "ereal x    < \<infinity>           \<longleftrightarrow> True"
 | "        -\<infinity> < ereal r     \<longleftrightarrow> True"
 | "        -\<infinity> < (\<infinity>::ereal) \<longleftrightarrow> True"
 proof goal_cases
   case prems: (1 P x)
   then obtain a b where "x = (a,b)" by (cases x) auto
   with prems show P by (cases rule: ereal2_cases[of a b]) auto
 qed simp_all
 termination by (relation "{}") simp
 
 definition "x \<le> (y::ereal) \<longleftrightarrow> x < y \<or> x = y"
 
 lemma ereal_infty_less[simp]:
   fixes x :: ereal
   shows "x < \<infinity> \<longleftrightarrow> (x \<noteq> \<infinity>)"
     "-\<infinity> < x \<longleftrightarrow> (x \<noteq> -\<infinity>)"
   by (cases x, simp_all) (cases x, simp_all)
 
 lemma ereal_infty_less_eq[simp]:
   fixes x :: ereal
   shows "\<infinity> \<le> x \<longleftrightarrow> x = \<infinity>"
     and "x \<le> -\<infinity> \<longleftrightarrow> x = -\<infinity>"
   by (auto simp add: less_eq_ereal_def)
 
 lemma ereal_less[simp]:
   "ereal r < 0 \<longleftrightarrow> (r < 0)"
   "0 < ereal r \<longleftrightarrow> (0 < r)"
   "ereal r < 1 \<longleftrightarrow> (r < 1)"
   "1 < ereal r \<longleftrightarrow> (1 < r)"
   "0 < (\<infinity>::ereal)"
   "-(\<infinity>::ereal) < 0"
   by (simp_all add: zero_ereal_def one_ereal_def)
 
 lemma ereal_less_eq[simp]:
   "x \<le> (\<infinity>::ereal)"
   "-(\<infinity>::ereal) \<le> x"
   "ereal r \<le> ereal p \<longleftrightarrow> r \<le> p"
   "ereal r \<le> 0 \<longleftrightarrow> r \<le> 0"
   "0 \<le> ereal r \<longleftrightarrow> 0 \<le> r"
   "ereal r \<le> 1 \<longleftrightarrow> r \<le> 1"
   "1 \<le> ereal r \<longleftrightarrow> 1 \<le> r"
   by (auto simp add: less_eq_ereal_def zero_ereal_def one_ereal_def)
 
 lemma ereal_infty_less_eq2:
   "a \<le> b \<Longrightarrow> a = \<infinity> \<Longrightarrow> b = (\<infinity>::ereal)"
   "a \<le> b \<Longrightarrow> b = -\<infinity> \<Longrightarrow> a = -(\<infinity>::ereal)"
   by simp_all
 
 instance
 proof
   fix x y z :: ereal
   show "x \<le> x"
     by (cases x) simp_all
   show "x < y \<longleftrightarrow> x \<le> y \<and> \<not> y \<le> x"
     by (cases rule: ereal2_cases[of x y]) auto
   show "x \<le> y \<or> y \<le> x "
     by (cases rule: ereal2_cases[of x y]) auto
   {
     assume "x \<le> y" "y \<le> x"
     then show "x = y"
       by (cases rule: ereal2_cases[of x y]) auto
   }
   {
     assume "x \<le> y" "y \<le> z"
     then show "x \<le> z"
       by (cases rule: ereal3_cases[of x y z]) auto
   }
 qed
 
 end
 
 lemma ereal_dense2: "x < y \<Longrightarrow> \<exists>z. x < ereal z \<and> ereal z < y"
   using lt_ex gt_ex dense by (cases x y rule: ereal2_cases) auto
 
 instance ereal :: dense_linorder
   by standard (blast dest: ereal_dense2)
 
 instance ereal :: ordered_comm_monoid_add
 proof
   fix a b c :: ereal
   assume "a \<le> b"
   then show "c + a \<le> c + b"
     by (cases rule: ereal3_cases[of a b c]) auto
 qed
 
 lemma ereal_one_not_less_zero_ereal[simp]: "\<not> 1 < (0::ereal)"
   by (simp add: zero_ereal_def)
 
 lemma real_of_ereal_positive_mono:
   fixes x y :: ereal
   shows "0 \<le> x \<Longrightarrow> x \<le> y \<Longrightarrow> y \<noteq> \<infinity> \<Longrightarrow> real_of_ereal x \<le> real_of_ereal y"
   by (cases rule: ereal2_cases[of x y]) auto
 
 lemma ereal_MInfty_lessI[intro, simp]:
   fixes a :: ereal
   shows "a \<noteq> -\<infinity> \<Longrightarrow> -\<infinity> < a"
   by (cases a) auto
 
 lemma ereal_less_PInfty[intro, simp]:
   fixes a :: ereal
   shows "a \<noteq> \<infinity> \<Longrightarrow> a < \<infinity>"
   by (cases a) auto
 
 lemma ereal_less_ereal_Ex:
   fixes a b :: ereal
   shows "x < ereal r \<longleftrightarrow> x = -\<infinity> \<or> (\<exists>p. p < r \<and> x = ereal p)"
   by (cases x) auto
 
 lemma less_PInf_Ex_of_nat: "x \<noteq> \<infinity> \<longleftrightarrow> (\<exists>n::nat. x < ereal (real n))"
 proof (cases x)
   case (real r)
   then show ?thesis
     using reals_Archimedean2[of r] by simp
 qed simp_all
 
 lemma ereal_add_strict_mono2:
   fixes a b c d :: ereal
   assumes "a < b" and "c < d"
   shows "a + c < b + d"
   using assms
   by (cases a; force simp add: elim: less_ereal.elims)
 
 lemma ereal_minus_le_minus[simp]:
   fixes a b :: ereal
   shows "- a \<le> - b \<longleftrightarrow> b \<le> a"
   by (cases rule: ereal2_cases[of a b]) auto
 
 lemma ereal_minus_less_minus[simp]:
   fixes a b :: ereal
   shows "- a < - b \<longleftrightarrow> b < a"
   by (cases rule: ereal2_cases[of a b]) auto
 
 lemma ereal_le_real_iff:
   "x \<le> real_of_ereal y \<longleftrightarrow> (\<bar>y\<bar> \<noteq> \<infinity> \<longrightarrow> ereal x \<le> y) \<and> (\<bar>y\<bar> = \<infinity> \<longrightarrow> x \<le> 0)"
   by (cases y) auto
 
 lemma real_le_ereal_iff:
   "real_of_ereal y \<le> x \<longleftrightarrow> (\<bar>y\<bar> \<noteq> \<infinity> \<longrightarrow> y \<le> ereal x) \<and> (\<bar>y\<bar> = \<infinity> \<longrightarrow> 0 \<le> x)"
   by (cases y) auto
 
 lemma ereal_less_real_iff:
   "x < real_of_ereal y \<longleftrightarrow> (\<bar>y\<bar> \<noteq> \<infinity> \<longrightarrow> ereal x < y) \<and> (\<bar>y\<bar> = \<infinity> \<longrightarrow> x < 0)"
   by (cases y) auto
 
 lemma real_less_ereal_iff:
   "real_of_ereal y < x \<longleftrightarrow> (\<bar>y\<bar> \<noteq> \<infinity> \<longrightarrow> y < ereal x) \<and> (\<bar>y\<bar> = \<infinity> \<longrightarrow> 0 < x)"
   by (cases y) auto
 
 text \<open>
   To help with inferences like \<^prop>\<open>a < ereal x \<Longrightarrow> x < y \<Longrightarrow> a < ereal y\<close>,
   where x and y are real.
 \<close>
 
 lemma le_ereal_le: "a \<le> ereal x \<Longrightarrow> x \<le> y \<Longrightarrow> a \<le> ereal y"
   using ereal_less_eq(3) order.trans by blast
 
 lemma le_ereal_less: "a \<le> ereal x \<Longrightarrow> x < y \<Longrightarrow> a < ereal y"
   by (simp add: le_less_trans)
 
 lemma less_ereal_le: "a < ereal x \<Longrightarrow> x \<le> y \<Longrightarrow> a < ereal y"
   using ereal_less_ereal_Ex by auto
 
 lemma ereal_le_le: "ereal y \<le> a \<Longrightarrow> x \<le> y \<Longrightarrow> ereal x \<le> a"
   by (simp add: order_subst2)
 
 lemma ereal_le_less: "ereal y \<le> a \<Longrightarrow> x < y \<Longrightarrow> ereal x < a"
   by (simp add: dual_order.strict_trans1)
 
 lemma ereal_less_le: "ereal y < a \<Longrightarrow> x \<le> y \<Longrightarrow> ereal x < a"
   using ereal_less_eq(3) le_less_trans by blast
 
 lemma real_of_ereal_pos:
   fixes x :: ereal
   shows "0 \<le> x \<Longrightarrow> 0 \<le> real_of_ereal x" by (cases x) auto
 
 lemmas real_of_ereal_ord_simps =
   ereal_le_real_iff real_le_ereal_iff ereal_less_real_iff real_less_ereal_iff
 
 lemma abs_ereal_ge0[simp]: "0 \<le> x \<Longrightarrow> \<bar>x :: ereal\<bar> = x"
   by (cases x) auto
 
 lemma abs_ereal_less0[simp]: "x < 0 \<Longrightarrow> \<bar>x :: ereal\<bar> = -x"
   by (cases x) auto
 
 lemma abs_ereal_pos[simp]: "0 \<le> \<bar>x :: ereal\<bar>"
   by (cases x) auto
 
 lemma ereal_abs_leI:
   fixes x y :: ereal
   shows "\<lbrakk> x \<le> y; -x \<le> y \<rbrakk> \<Longrightarrow> \<bar>x\<bar> \<le> y"
 by(cases x y rule: ereal2_cases)(simp_all)
 
 lemma ereal_abs_add:
   fixes a b::ereal
   shows "abs(a+b) \<le> abs a + abs b"
 by (cases rule: ereal2_cases[of a b]) (auto)
 
 lemma real_of_ereal_le_0[simp]: "real_of_ereal (x :: ereal) \<le> 0 \<longleftrightarrow> x \<le> 0 \<or> x = \<infinity>"
   by (cases x) auto
 
 lemma abs_real_of_ereal[simp]: "\<bar>real_of_ereal (x :: ereal)\<bar> = real_of_ereal \<bar>x\<bar>"
   by (cases x) auto
 
 lemma zero_less_real_of_ereal:
   fixes x :: ereal
   shows "0 < real_of_ereal x \<longleftrightarrow> 0 < x \<and> x \<noteq> \<infinity>"
   by (cases x) auto
 
 lemma ereal_0_le_uminus_iff[simp]:
   fixes a :: ereal
   shows "0 \<le> - a \<longleftrightarrow> a \<le> 0"
   by (cases rule: ereal2_cases[of a]) auto
 
 lemma ereal_uminus_le_0_iff[simp]:
   fixes a :: ereal
   shows "- a \<le> 0 \<longleftrightarrow> 0 \<le> a"
   by (cases rule: ereal2_cases[of a]) auto
 
 lemma ereal_add_strict_mono:
   fixes a b c d :: ereal
   assumes "a \<le> b"
     and "0 \<le> a"
     and "a \<noteq> \<infinity>"
     and "c < d"
   shows "a + c < b + d"
   using assms
   by (cases rule: ereal3_cases[case_product ereal_cases, of a b c d]) auto
 
 lemma ereal_less_add:
   fixes a b c :: ereal
   shows "\<bar>a\<bar> \<noteq> \<infinity> \<Longrightarrow> c < b \<Longrightarrow> a + c < a + b"
   by (cases rule: ereal2_cases[of b c]) auto
 
 lemma ereal_add_nonneg_eq_0_iff:
   fixes a b :: ereal
   shows "0 \<le> a \<Longrightarrow> 0 \<le> b \<Longrightarrow> a + b = 0 \<longleftrightarrow> a = 0 \<and> b = 0"
   by (cases a b rule: ereal2_cases) auto
 
 lemma ereal_uminus_eq_reorder: "- a = b \<longleftrightarrow> a = (-b::ereal)"
   by auto
 
 lemma ereal_uminus_less_reorder: "- a < b \<longleftrightarrow> -b < (a::ereal)"
   by (subst (3) ereal_uminus_uminus[symmetric]) (simp only: ereal_minus_less_minus)
 
 lemma ereal_less_uminus_reorder: "a < - b \<longleftrightarrow> b < - (a::ereal)"
   by (subst (3) ereal_uminus_uminus[symmetric]) (simp only: ereal_minus_less_minus)
 
 lemma ereal_uminus_le_reorder: "- a \<le> b \<longleftrightarrow> -b \<le> (a::ereal)"
   by (subst (3) ereal_uminus_uminus[symmetric]) (simp only: ereal_minus_le_minus)
 
 lemmas ereal_uminus_reorder =
   ereal_uminus_eq_reorder ereal_uminus_less_reorder ereal_uminus_le_reorder
 
 lemma ereal_bot:
   fixes x :: ereal
   assumes "\<And>B. x \<le> ereal B"
   shows "x = - \<infinity>"
 proof (cases x)
   case (real r)
   with assms[of "r - 1"] show ?thesis
     by auto
 next
   case PInf
   with assms[of 0] show ?thesis
     by auto
 next
   case MInf
   then show ?thesis
     by simp
 qed
 
 lemma ereal_top:
   fixes x :: ereal
   assumes "\<And>B. x \<ge> ereal B"
   shows "x = \<infinity>"
 proof (cases x)
   case (real r)
   with assms[of "r + 1"] show ?thesis
     by auto
 next
   case MInf
   with assms[of 0] show ?thesis
     by auto
 next
   case PInf
   then show ?thesis
     by simp
 qed
 
 lemma
   shows ereal_max[simp]: "ereal (max x y) = max (ereal x) (ereal y)"
     and ereal_min[simp]: "ereal (min x y) = min (ereal x) (ereal y)"
   by (simp_all add: min_def max_def)
 
 lemma ereal_max_0: "max 0 (ereal r) = ereal (max 0 r)"
   by (auto simp: zero_ereal_def)
 
 lemma
   fixes f :: "nat \<Rightarrow> ereal"
   shows ereal_incseq_uminus[simp]: "incseq (\<lambda>x. - f x) \<longleftrightarrow> decseq f"
     and ereal_decseq_uminus[simp]: "decseq (\<lambda>x. - f x) \<longleftrightarrow> incseq f"
   unfolding decseq_def incseq_def by auto
 
 lemma incseq_ereal: "incseq f \<Longrightarrow> incseq (\<lambda>x. ereal (f x))"
   unfolding incseq_def by auto
 
 lemma sum_ereal[simp]: "(\<Sum>x\<in>A. ereal (f x)) = ereal (\<Sum>x\<in>A. f x)"
 proof (cases "finite A")
   case True
   then show ?thesis by induct auto
 next
   case False
   then show ?thesis by simp
 qed
 
 lemma sum_list_ereal [simp]: "sum_list (map (\<lambda>x. ereal (f x)) xs) = ereal (sum_list (map f xs))"
   by (induction xs) simp_all
 
 lemma sum_Pinfty:
   fixes f :: "'a \<Rightarrow> ereal"
   shows "(\<Sum>x\<in>P. f x) = \<infinity> \<longleftrightarrow> finite P \<and> (\<exists>i\<in>P. f i = \<infinity>)"
 proof safe
   assume *: "sum f P = \<infinity>"
   show "finite P"
   proof (rule ccontr)
     assume "\<not> finite P"
     with * show False
       by auto
   qed
   show "\<exists>i\<in>P. f i = \<infinity>"
   proof (rule ccontr)
     assume "\<not> ?thesis"
     then have "\<And>i. i \<in> P \<Longrightarrow> f i \<noteq> \<infinity>"
       by auto
     with \<open>finite P\<close> have "sum f P \<noteq> \<infinity>"
       by induct auto
     with * show False
       by auto
   qed
 next
   fix i
   assume "finite P" and "i \<in> P" and "f i = \<infinity>"
   then show "sum f P = \<infinity>"
   proof induct
     case (insert x A)
     show ?case using insert by (cases "x = i") auto
   qed simp
 qed
 
 lemma sum_Inf:
   fixes f :: "'a \<Rightarrow> ereal"
   shows "\<bar>sum f A\<bar> = \<infinity> \<longleftrightarrow> finite A \<and> (\<exists>i\<in>A. \<bar>f i\<bar> = \<infinity>)"
 proof
   assume *: "\<bar>sum f A\<bar> = \<infinity>"
   have "finite A"
     by (rule ccontr) (insert *, auto)
   moreover have "\<exists>i\<in>A. \<bar>f i\<bar> = \<infinity>"
   proof (rule ccontr)
     assume "\<not> ?thesis"
     then have "\<forall>i\<in>A. \<exists>r. f i = ereal r"
       by auto
     from bchoice[OF this] obtain r where "\<forall>x\<in>A. f x = ereal (r x)" ..
     with * show False
       by auto
   qed
   ultimately show "finite A \<and> (\<exists>i\<in>A. \<bar>f i\<bar> = \<infinity>)"
     by auto
 next
   assume "finite A \<and> (\<exists>i\<in>A. \<bar>f i\<bar> = \<infinity>)"
   then obtain i where "finite A" "i \<in> A" and "\<bar>f i\<bar> = \<infinity>"
     by auto
   then show "\<bar>sum f A\<bar> = \<infinity>"
   proof induct
     case (insert j A)
     then show ?case
       by (cases rule: ereal3_cases[of "f i" "f j" "sum f A"]) auto
   qed simp
 qed
 
 lemma sum_real_of_ereal:
   fixes f :: "'i \<Rightarrow> ereal"
   assumes "\<And>x. x \<in> S \<Longrightarrow> \<bar>f x\<bar> \<noteq> \<infinity>"
   shows "(\<Sum>x\<in>S. real_of_ereal (f x)) = real_of_ereal (sum f S)"
 proof -
   have "\<forall>x\<in>S. \<exists>r. f x = ereal r"
   proof
     fix x
     assume "x \<in> S"
     from assms[OF this] show "\<exists>r. f x = ereal r"
       by (cases "f x") auto
   qed
   from bchoice[OF this] obtain r where "\<forall>x\<in>S. f x = ereal (r x)" ..
   then show ?thesis
     by simp
 qed
 
 lemma sum_ereal_0:
   fixes f :: "'a \<Rightarrow> ereal"
   assumes "finite A"
     and "\<And>i. i \<in> A \<Longrightarrow> 0 \<le> f i"
   shows "(\<Sum>x\<in>A. f x) = 0 \<longleftrightarrow> (\<forall>i\<in>A. f i = 0)"
 proof
   assume "sum f A = 0" with assms show "\<forall>i\<in>A. f i = 0"
   proof (induction A)
     case (insert a A)
     then have "f a = 0 \<and> (\<Sum>a\<in>A. f a) = 0"
       by (subst ereal_add_nonneg_eq_0_iff[symmetric]) (simp_all add: sum_nonneg)
     with insert show ?case
       by simp
   qed simp
 qed auto
 
 subsubsection "Multiplication"
 
 instantiation ereal :: "{comm_monoid_mult,sgn}"
 begin
 
 function sgn_ereal :: "ereal \<Rightarrow> ereal" where
   "sgn (ereal r) = ereal (sgn r)"
 | "sgn (\<infinity>::ereal) = 1"
 | "sgn (-\<infinity>::ereal) = -1"
 by (auto intro: ereal_cases)
 termination by standard (rule wf_empty)
 
 function times_ereal where
   "ereal r * ereal p = ereal (r * p)"
 | "ereal r * \<infinity> = (if r = 0 then 0 else if r > 0 then \<infinity> else -\<infinity>)"
 | "\<infinity> * ereal r = (if r = 0 then 0 else if r > 0 then \<infinity> else -\<infinity>)"
 | "ereal r * -\<infinity> = (if r = 0 then 0 else if r > 0 then -\<infinity> else \<infinity>)"
 | "-\<infinity> * ereal r = (if r = 0 then 0 else if r > 0 then -\<infinity> else \<infinity>)"
 | "(\<infinity>::ereal) * \<infinity> = \<infinity>"
 | "-(\<infinity>::ereal) * \<infinity> = -\<infinity>"
 | "(\<infinity>::ereal) * -\<infinity> = -\<infinity>"
 | "-(\<infinity>::ereal) * -\<infinity> = \<infinity>"
 proof goal_cases
   case prems: (1 P x)
   then obtain a b where "x = (a, b)"
     by (cases x) auto
   with prems show P
     by (cases rule: ereal2_cases[of a b]) auto
 qed simp_all
 termination by (relation "{}") simp
 
 instance
 proof
   fix a b c :: ereal
   show "1 * a = a"
     by (cases a) (simp_all add: one_ereal_def)
   show "a * b = b * a"
     by (cases rule: ereal2_cases[of a b]) simp_all
   show "a * b * c = a * (b * c)"
     by (cases rule: ereal3_cases[of a b c])
        (simp_all add: zero_ereal_def zero_less_mult_iff)
 qed
 
 end
 
 lemma [simp]:
   shows ereal_1_times: "ereal 1 * x = x"
   and times_ereal_1: "x * ereal 1 = x"
 by(simp_all flip: one_ereal_def)
 
 lemma one_not_le_zero_ereal[simp]: "\<not> (1 \<le> (0::ereal))"
   by (simp add: one_ereal_def zero_ereal_def)
 
 lemma real_ereal_1[simp]: "real_of_ereal (1::ereal) = 1"
   unfolding one_ereal_def by simp
 
 lemma real_of_ereal_le_1:
   fixes a :: ereal
   shows "a \<le> 1 \<Longrightarrow> real_of_ereal a \<le> 1"
   by (cases a) (auto simp: one_ereal_def)
 
 lemma abs_ereal_one[simp]: "\<bar>1\<bar> = (1::ereal)"
   unfolding one_ereal_def by simp
 
 lemma ereal_mult_zero[simp]:
   fixes a :: ereal
   shows "a * 0 = 0"
   by (cases a) (simp_all add: zero_ereal_def)
 
 lemma ereal_zero_mult[simp]:
   fixes a :: ereal
   shows "0 * a = 0"
   by (cases a) (simp_all add: zero_ereal_def)
 
 lemma ereal_m1_less_0[simp]: "-(1::ereal) < 0"
   by (simp add: zero_ereal_def one_ereal_def)
 
 lemma ereal_times[simp]:
   "1 \<noteq> (\<infinity>::ereal)" "(\<infinity>::ereal) \<noteq> 1"
   "1 \<noteq> -(\<infinity>::ereal)" "-(\<infinity>::ereal) \<noteq> 1"
   by (auto simp: one_ereal_def)
 
 lemma ereal_plus_1[simp]:
   "1 + ereal r = ereal (r + 1)"
   "ereal r + 1 = ereal (r + 1)"
   "1 + -(\<infinity>::ereal) = -\<infinity>"
   "-(\<infinity>::ereal) + 1 = -\<infinity>"
   unfolding one_ereal_def by auto
 
 lemma ereal_zero_times[simp]:
   fixes a b :: ereal
   shows "a * b = 0 \<longleftrightarrow> a = 0 \<or> b = 0"
   by (cases rule: ereal2_cases[of a b]) auto
 
 lemma ereal_mult_eq_PInfty[simp]:
   "a * b = (\<infinity>::ereal) \<longleftrightarrow>
     (a = \<infinity> \<and> b > 0) \<or> (a > 0 \<and> b = \<infinity>) \<or> (a = -\<infinity> \<and> b < 0) \<or> (a < 0 \<and> b = -\<infinity>)"
   by (cases rule: ereal2_cases[of a b]) auto
 
 lemma ereal_mult_eq_MInfty[simp]:
   "a * b = -(\<infinity>::ereal) \<longleftrightarrow>
     (a = \<infinity> \<and> b < 0) \<or> (a < 0 \<and> b = \<infinity>) \<or> (a = -\<infinity> \<and> b > 0) \<or> (a > 0 \<and> b = -\<infinity>)"
   by (cases rule: ereal2_cases[of a b]) auto
 
 lemma ereal_abs_mult: "\<bar>x * y :: ereal\<bar> = \<bar>x\<bar> * \<bar>y\<bar>"
   by (cases x y rule: ereal2_cases) (auto simp: abs_mult)
 
 lemma ereal_0_less_1[simp]: "0 < (1::ereal)"
   by (simp_all add: zero_ereal_def one_ereal_def)
 
 lemma ereal_mult_minus_left[simp]:
   fixes a b :: ereal
   shows "-a * b = - (a * b)"
   by (cases rule: ereal2_cases[of a b]) auto
 
 lemma ereal_mult_minus_right[simp]:
   fixes a b :: ereal
   shows "a * -b = - (a * b)"
   by (cases rule: ereal2_cases[of a b]) auto
 
 lemma ereal_mult_infty[simp]:
   "a * (\<infinity>::ereal) = (if a = 0 then 0 else if 0 < a then \<infinity> else - \<infinity>)"
   by (cases a) auto
 
 lemma ereal_infty_mult[simp]:
   "(\<infinity>::ereal) * a = (if a = 0 then 0 else if 0 < a then \<infinity> else - \<infinity>)"
   by (cases a) auto
 
 lemma ereal_mult_strict_right_mono:
   assumes "a < b"
     and "0 < c"
     and "c < (\<infinity>::ereal)"
   shows "a * c < b * c"
   using assms
   by (cases rule: ereal3_cases[of a b c]) (auto simp: zero_le_mult_iff)
 
 lemma ereal_mult_strict_left_mono:
   "a < b \<Longrightarrow> 0 < c \<Longrightarrow> c < (\<infinity>::ereal) \<Longrightarrow> c * a < c * b"
   using ereal_mult_strict_right_mono
   by (simp add: mult.commute[of c])
 
 lemma ereal_mult_right_mono:
   fixes a b c :: ereal
   assumes "a \<le> b" "0 \<le> c"
   shows "a * c \<le> b * c"
 proof (cases "c = 0")
   case False
   with assms show ?thesis
     by (cases rule: ereal3_cases[of a b c]) auto
 qed auto
 
 lemma ereal_mult_left_mono:
   fixes a b c :: ereal
   shows "a \<le> b \<Longrightarrow> 0 \<le> c \<Longrightarrow> c * a \<le> c * b"
   using ereal_mult_right_mono
   by (simp add: mult.commute[of c])
 
 lemma ereal_mult_mono:
   fixes a b c d::ereal
   assumes "b \<ge> 0" "c \<ge> 0" "a \<le> b" "c \<le> d"
   shows "a * c \<le> b * d"
 by (metis ereal_mult_right_mono mult.commute order_trans assms)
 
 lemma ereal_mult_mono':
   fixes a b c d::ereal
   assumes "a \<ge> 0" "c \<ge> 0" "a \<le> b" "c \<le> d"
   shows "a * c \<le> b * d"
 by (metis ereal_mult_right_mono mult.commute order_trans assms)
 
 lemma ereal_mult_mono_strict:
   fixes a b c d::ereal
   assumes "b > 0" "c > 0" "a < b" "c < d"
   shows "a * c < b * d"
 proof -
   have "c < \<infinity>" using \<open>c < d\<close> by auto
   then have "a * c < b * c" by (metis ereal_mult_strict_left_mono[OF assms(3) assms(2)] mult.commute)
   moreover have "b * c \<le> b * d" using assms(2) assms(4) by (simp add: assms(1) ereal_mult_left_mono less_imp_le)
   ultimately show ?thesis by simp
 qed
 
 lemma ereal_mult_mono_strict':
   fixes a b c d::ereal
   assumes "a > 0" "c > 0" "a < b" "c < d"
   shows "a * c < b * d"
   using assms ereal_mult_mono_strict by auto
 
 lemma zero_less_one_ereal[simp]: "0 \<le> (1::ereal)"
   by (simp add: one_ereal_def zero_ereal_def)
 
 lemma ereal_0_le_mult[simp]: "0 \<le> a \<Longrightarrow> 0 \<le> b \<Longrightarrow> 0 \<le> a * (b :: ereal)"
   by (cases rule: ereal2_cases[of a b]) auto
 
 lemma ereal_right_distrib:
   fixes r a b :: ereal
   shows "0 \<le> a \<Longrightarrow> 0 \<le> b \<Longrightarrow> r * (a + b) = r * a + r * b"
   by (cases rule: ereal3_cases[of r a b]) (simp_all add: field_simps)
 
 lemma ereal_left_distrib:
   fixes r a b :: ereal
   shows "0 \<le> a \<Longrightarrow> 0 \<le> b \<Longrightarrow> (a + b) * r = a * r + b * r"
   by (cases rule: ereal3_cases[of r a b]) (simp_all add: field_simps)
 
 lemma ereal_mult_le_0_iff:
   fixes a b :: ereal
   shows "a * b \<le> 0 \<longleftrightarrow> (0 \<le> a \<and> b \<le> 0) \<or> (a \<le> 0 \<and> 0 \<le> b)"
   by (cases rule: ereal2_cases[of a b]) (simp_all add: mult_le_0_iff)
 
 lemma ereal_zero_le_0_iff:
   fixes a b :: ereal
   shows "0 \<le> a * b \<longleftrightarrow> (0 \<le> a \<and> 0 \<le> b) \<or> (a \<le> 0 \<and> b \<le> 0)"
   by (cases rule: ereal2_cases[of a b]) (simp_all add: zero_le_mult_iff)
 
 lemma ereal_mult_less_0_iff:
   fixes a b :: ereal
   shows "a * b < 0 \<longleftrightarrow> (0 < a \<and> b < 0) \<or> (a < 0 \<and> 0 < b)"
   by (cases rule: ereal2_cases[of a b]) (simp_all add: mult_less_0_iff)
 
 lemma ereal_zero_less_0_iff:
   fixes a b :: ereal
   shows "0 < a * b \<longleftrightarrow> (0 < a \<and> 0 < b) \<or> (a < 0 \<and> b < 0)"
   by (cases rule: ereal2_cases[of a b]) (simp_all add: zero_less_mult_iff)
 
 lemma ereal_left_mult_cong:
   fixes a b c :: ereal
   shows  "c = d \<Longrightarrow> (d \<noteq> 0 \<Longrightarrow> a = b) \<Longrightarrow> a * c = b * d"
   by (cases "c = 0") simp_all
 
 lemma ereal_right_mult_cong:
   fixes a b c :: ereal
   shows "c = d \<Longrightarrow> (d \<noteq> 0 \<Longrightarrow> a = b) \<Longrightarrow> c * a = d * b"
   by (cases "c = 0") simp_all
 
 lemma ereal_distrib:
   fixes a b c :: ereal
   assumes "a \<noteq> \<infinity> \<or> b \<noteq> -\<infinity>"
     and "a \<noteq> -\<infinity> \<or> b \<noteq> \<infinity>"
     and "\<bar>c\<bar> \<noteq> \<infinity>"
   shows "(a + b) * c = a * c + b * c"
   using assms
   by (cases rule: ereal3_cases[of a b c]) (simp_all add: field_simps)
 
 lemma numeral_eq_ereal [simp]: "numeral w = ereal (numeral w)"
 proof (induct w rule: num_induct)
   case One
   then show ?case
     by simp
 next
   case (inc x)
   then show ?case
     by (simp add: inc numeral_inc)
 qed
 
 lemma distrib_left_ereal_nn:
   "c \<ge> 0 \<Longrightarrow> (x + y) * ereal c = x * ereal c + y * ereal c"
   by(cases x y rule: ereal2_cases)(simp_all add: ring_distribs)
 
 lemma sum_ereal_right_distrib:
   fixes f :: "'a \<Rightarrow> ereal"
   shows "(\<And>i. i \<in> A \<Longrightarrow> 0 \<le> f i) \<Longrightarrow> r * sum f A = (\<Sum>n\<in>A. r * f n)"
   by (induct A rule: infinite_finite_induct)  (auto simp: ereal_right_distrib sum_nonneg)
 
 lemma sum_ereal_left_distrib:
   "(\<And>i. i \<in> A \<Longrightarrow> 0 \<le> f i) \<Longrightarrow> sum f A * r = (\<Sum>n\<in>A. f n * r :: ereal)"
   using sum_ereal_right_distrib[of A f r] by (simp add: mult_ac)
 
 lemma sum_distrib_right_ereal:
   "c \<ge> 0 \<Longrightarrow> sum f A * ereal c = (\<Sum>x\<in>A. f x * c :: ereal)"
 by(subst sum_comp_morphism[where h="\<lambda>x. x * ereal c", symmetric])(simp_all add: distrib_left_ereal_nn)
 
 lemma ereal_le_epsilon:
   fixes x y :: ereal
   assumes "\<And>e. 0 < e \<Longrightarrow> x \<le> y + e"
   shows "x \<le> y"
 proof (cases "x = -\<infinity> \<or> x = \<infinity> \<or> y = -\<infinity> \<or> y = \<infinity>")
   case True
   then show ?thesis
     using assms[of 1] by auto
 next
   case False
   then obtain p q where "x = ereal p" "y = ereal q"
     by (metis MInfty_eq_minfinity ereal.distinct(3) uminus_ereal.elims)
   then show ?thesis 
     by (metis assms field_le_epsilon ereal_less(2) ereal_less_eq(3) plus_ereal.simps(1))
 qed
 
 lemma ereal_le_epsilon2:
   fixes x y :: ereal
   assumes "\<And>e::real. 0 < e \<Longrightarrow> x \<le> y + ereal e"
   shows "x \<le> y"
 proof (rule ereal_le_epsilon)
   show "\<And>\<epsilon>::ereal. 0 < \<epsilon> \<Longrightarrow> x \<le> y + \<epsilon>"
   using assms less_ereal.elims(2) zero_less_real_of_ereal by fastforce
 qed
 
 lemma ereal_le_real:
   fixes x y :: ereal
   assumes "\<And>z. x \<le> ereal z \<Longrightarrow> y \<le> ereal z"
   shows "y \<le> x"
   by (metis assms ereal_bot ereal_cases ereal_infty_less_eq(2) ereal_less_eq(1) linorder_le_cases)
 
 lemma prod_ereal_0:
   fixes f :: "'a \<Rightarrow> ereal"
   shows "(\<Prod>i\<in>A. f i) = 0 \<longleftrightarrow> finite A \<and> (\<exists>i\<in>A. f i = 0)"
 proof (cases "finite A")
   case True
   then show ?thesis by (induct A) auto
 qed auto
 
 lemma prod_ereal_pos:
   fixes f :: "'a \<Rightarrow> ereal"
   assumes pos: "\<And>i. i \<in> I \<Longrightarrow> 0 \<le> f i"
   shows "0 \<le> (\<Prod>i\<in>I. f i)"
 proof (cases "finite I")
   case True
   from this pos show ?thesis
     by induct auto
 qed auto
 
 lemma prod_PInf:
   fixes f :: "'a \<Rightarrow> ereal"
   assumes "\<And>i. i \<in> I \<Longrightarrow> 0 \<le> f i"
   shows "(\<Prod>i\<in>I. f i) = \<infinity> \<longleftrightarrow> finite I \<and> (\<exists>i\<in>I. f i = \<infinity>) \<and> (\<forall>i\<in>I. f i \<noteq> 0)"
 proof (cases "finite I")
   case True
   from this assms show ?thesis
   proof (induct I)
     case (insert i I)
     then have pos: "0 \<le> f i" "0 \<le> prod f I"
       by (auto intro!: prod_ereal_pos)
     from insert have "(\<Prod>j\<in>insert i I. f j) = \<infinity> \<longleftrightarrow> prod f I * f i = \<infinity>"
       by auto
     also have "\<dots> \<longleftrightarrow> (prod f I = \<infinity> \<or> f i = \<infinity>) \<and> f i \<noteq> 0 \<and> prod f I \<noteq> 0"
       using prod_ereal_pos[of I f] pos
       by (cases rule: ereal2_cases[of "f i" "prod f I"]) auto
     also have "\<dots> \<longleftrightarrow> finite (insert i I) \<and> (\<exists>j\<in>insert i I. f j = \<infinity>) \<and> (\<forall>j\<in>insert i I. f j \<noteq> 0)"
       using insert by (auto simp: prod_ereal_0)
     finally show ?case .
   qed simp
 qed auto
 
 lemma prod_ereal: "(\<Prod>i\<in>A. ereal (f i)) = ereal (prod f A)"
 proof (cases "finite A")
   case True
   then show ?thesis
     by induct (auto simp: one_ereal_def)
 next
   case False
   then show ?thesis
     by (simp add: one_ereal_def)
 qed
 
 
 subsubsection \<open>Power\<close>
 
 lemma ereal_power[simp]: "(ereal x) ^ n = ereal (x^n)"
   by (induct n) (auto simp: one_ereal_def)
 
 lemma ereal_power_PInf[simp]: "(\<infinity>::ereal) ^ n = (if n = 0 then 1 else \<infinity>)"
   by (induct n) (auto simp: one_ereal_def)
 
 lemma ereal_power_uminus[simp]:
   fixes x :: ereal
   shows "(- x) ^ n = (if even n then x ^ n else - (x^n))"
   by (induct n) (auto simp: one_ereal_def)
 
 lemma ereal_power_numeral[simp]:
   "(numeral num :: ereal) ^ n = ereal (numeral num ^ n)"
   by (induct n) (auto simp: one_ereal_def)
 
 lemma zero_le_power_ereal[simp]:
   fixes a :: ereal
   assumes "0 \<le> a"
   shows "0 \<le> a ^ n"
   using assms by (induct n) (auto simp: ereal_zero_le_0_iff)
 
 
 subsubsection \<open>Subtraction\<close>
 
 lemma ereal_minus_minus_image[simp]:
   fixes S :: "ereal set"
   shows "uminus ` uminus ` S = S"
   by (auto simp: image_iff)
 
 lemma ereal_uminus_lessThan[simp]:
   fixes a :: ereal
   shows "uminus ` {..<a} = {-a<..}"
 proof -
   {
     fix x
     assume "-a < x"
     then have "- x < - (- a)"
       by (simp del: ereal_uminus_uminus)
     then have "- x < a"
       by simp
   }
   then show ?thesis
     by force
 qed
 
 lemma ereal_uminus_greaterThan[simp]: "uminus ` {(a::ereal)<..} = {..<-a}"
   by (metis ereal_uminus_lessThan ereal_uminus_uminus ereal_minus_minus_image)
 
 instantiation ereal :: minus
 begin
 
 definition "x - y = x + -(y::ereal)"
 instance ..
 
 end
 
 lemma ereal_minus[simp]:
   "ereal r - ereal p = ereal (r - p)"
   "-\<infinity> - ereal r = -\<infinity>"
   "ereal r - \<infinity> = -\<infinity>"
   "(\<infinity>::ereal) - x = \<infinity>"
   "-(\<infinity>::ereal) - \<infinity> = -\<infinity>"
   "x - -y = x + y"
   "x - 0 = x"
   "0 - x = -x"
   by (simp_all add: minus_ereal_def)
 
 lemma ereal_x_minus_x[simp]: "x - x = (if \<bar>x\<bar> = \<infinity> then \<infinity> else 0::ereal)"
   by (cases x) simp_all
 
 lemma ereal_eq_minus_iff:
   fixes x y z :: ereal
   shows "x = z - y \<longleftrightarrow>
     (\<bar>y\<bar> \<noteq> \<infinity> \<longrightarrow> x + y = z) \<and>
     (y = -\<infinity> \<longrightarrow> x = \<infinity>) \<and>
     (y = \<infinity> \<longrightarrow> z = \<infinity> \<longrightarrow> x = \<infinity>) \<and>
     (y = \<infinity> \<longrightarrow> z \<noteq> \<infinity> \<longrightarrow> x = -\<infinity>)"
   by (cases rule: ereal3_cases[of x y z]) auto
 
 lemma ereal_eq_minus:
   fixes x y z :: ereal
   shows "\<bar>y\<bar> \<noteq> \<infinity> \<Longrightarrow> x = z - y \<longleftrightarrow> x + y = z"
   by (auto simp: ereal_eq_minus_iff)
 
 lemma ereal_less_minus_iff:
   fixes x y z :: ereal
   shows "x < z - y \<longleftrightarrow>
     (y = \<infinity> \<longrightarrow> z = \<infinity> \<and> x \<noteq> \<infinity>) \<and>
     (y = -\<infinity> \<longrightarrow> x \<noteq> \<infinity>) \<and>
     (\<bar>y\<bar> \<noteq> \<infinity>\<longrightarrow> x + y < z)"
   by (cases rule: ereal3_cases[of x y z]) auto
 
 lemma ereal_less_minus:
   fixes x y z :: ereal
   shows "\<bar>y\<bar> \<noteq> \<infinity> \<Longrightarrow> x < z - y \<longleftrightarrow> x + y < z"
   by (auto simp: ereal_less_minus_iff)
 
 lemma ereal_le_minus_iff:
   fixes x y z :: ereal
   shows "x \<le> z - y \<longleftrightarrow> (y = \<infinity> \<longrightarrow> z \<noteq> \<infinity> \<longrightarrow> x = -\<infinity>) \<and> (\<bar>y\<bar> \<noteq> \<infinity> \<longrightarrow> x + y \<le> z)"
   by (cases rule: ereal3_cases[of x y z]) auto
 
 lemma ereal_le_minus:
   fixes x y z :: ereal
   shows "\<bar>y\<bar> \<noteq> \<infinity> \<Longrightarrow> x \<le> z - y \<longleftrightarrow> x + y \<le> z"
   by (auto simp: ereal_le_minus_iff)
 
 lemma ereal_minus_less_iff:
   fixes x y z :: ereal
   shows "x - y < z \<longleftrightarrow> y \<noteq> -\<infinity> \<and> (y = \<infinity> \<longrightarrow> x \<noteq> \<infinity> \<and> z \<noteq> -\<infinity>) \<and> (y \<noteq> \<infinity> \<longrightarrow> x < z + y)"
   by (cases rule: ereal3_cases[of x y z]) auto
 
 lemma ereal_minus_less:
   fixes x y z :: ereal
   shows "\<bar>y\<bar> \<noteq> \<infinity> \<Longrightarrow> x - y < z \<longleftrightarrow> x < z + y"
   by (auto simp: ereal_minus_less_iff)
 
 lemma ereal_minus_le_iff:
   fixes x y z :: ereal
   shows "x - y \<le> z \<longleftrightarrow>
     (y = -\<infinity> \<longrightarrow> z = \<infinity>) \<and>
     (y = \<infinity> \<longrightarrow> x = \<infinity> \<longrightarrow> z = \<infinity>) \<and>
     (\<bar>y\<bar> \<noteq> \<infinity> \<longrightarrow> x \<le> z + y)"
   by (cases rule: ereal3_cases[of x y z]) auto
 
 lemma ereal_minus_le:
   fixes x y z :: ereal
   shows "\<bar>y\<bar> \<noteq> \<infinity> \<Longrightarrow> x - y \<le> z \<longleftrightarrow> x \<le> z + y"
   by (auto simp: ereal_minus_le_iff)
 
 lemma ereal_minus_eq_minus_iff:
   fixes a b c :: ereal
   shows "a - b = a - c \<longleftrightarrow>
     b = c \<or> a = \<infinity> \<or> (a = -\<infinity> \<and> b \<noteq> -\<infinity> \<and> c \<noteq> -\<infinity>)"
   by (cases rule: ereal3_cases[of a b c]) auto
 
 lemma ereal_add_le_add_iff:
   fixes a b c :: ereal
   shows "c + a \<le> c + b \<longleftrightarrow>
     a \<le> b \<or> c = \<infinity> \<or> (c = -\<infinity> \<and> a \<noteq> \<infinity> \<and> b \<noteq> \<infinity>)"
   by (cases rule: ereal3_cases[of a b c]) (simp_all add: field_simps)
 
 lemma ereal_add_le_add_iff2:
   fixes a b c :: ereal
   shows "a + c \<le> b + c \<longleftrightarrow> a \<le> b \<or> c = \<infinity> \<or> (c = -\<infinity> \<and> a \<noteq> \<infinity> \<and> b \<noteq> \<infinity>)"
 by(cases rule: ereal3_cases[of a b c])(simp_all add: field_simps)
 
 lemma ereal_mult_le_mult_iff:
   fixes a b c :: ereal
   shows "\<bar>c\<bar> \<noteq> \<infinity> \<Longrightarrow> c * a \<le> c * b \<longleftrightarrow> (0 < c \<longrightarrow> a \<le> b) \<and> (c < 0 \<longrightarrow> b \<le> a)"
   by (cases rule: ereal3_cases[of a b c]) (simp_all add: mult_le_cancel_left)
 
 lemma ereal_minus_mono:
   fixes A B C D :: ereal assumes "A \<le> B" "D \<le> C"
   shows "A - C \<le> B - D"
   using assms
   by (cases rule: ereal3_cases[case_product ereal_cases, of A B C D]) simp_all
 
 lemma ereal_mono_minus_cancel:
   fixes a b c :: ereal
   shows "c - a \<le> c - b \<Longrightarrow> 0 \<le> c \<Longrightarrow> c < \<infinity> \<Longrightarrow> b \<le> a"
   by (cases a b c rule: ereal3_cases) auto
 
 lemma real_of_ereal_minus:
   fixes a b :: ereal
   shows "real_of_ereal (a - b) = (if \<bar>a\<bar> = \<infinity> \<or> \<bar>b\<bar> = \<infinity> then 0 else real_of_ereal a - real_of_ereal b)"
   by (cases rule: ereal2_cases[of a b]) auto
 
 lemma real_of_ereal_minus': "\<bar>x\<bar> = \<infinity> \<longleftrightarrow> \<bar>y\<bar> = \<infinity> \<Longrightarrow> real_of_ereal x - real_of_ereal y = real_of_ereal (x - y :: ereal)"
 by(subst real_of_ereal_minus) auto
 
 lemma ereal_diff_positive:
   fixes a b :: ereal shows "a \<le> b \<Longrightarrow> 0 \<le> b - a"
   by (cases rule: ereal2_cases[of a b]) auto
 
 lemma ereal_between:
   fixes x e :: ereal
   assumes "\<bar>x\<bar> \<noteq> \<infinity>"
     and "0 < e"
   shows "x - e < x"
     and "x < x + e"
   using assms  by (cases x, cases e, auto)+
 
 lemma ereal_minus_eq_PInfty_iff:
   fixes x y :: ereal
   shows "x - y = \<infinity> \<longleftrightarrow> y = -\<infinity> \<or> x = \<infinity>"
   by (cases x y rule: ereal2_cases) simp_all
 
 lemma ereal_diff_add_eq_diff_diff_swap:
   fixes x y z :: ereal
   shows "\<bar>y\<bar> \<noteq> \<infinity> \<Longrightarrow> x - (y + z) = x - y - z"
   by(cases x y z rule: ereal3_cases) simp_all
 
 lemma ereal_diff_add_assoc2:
   fixes x y z :: ereal
   shows "x + y - z = x - z + y"
   by(cases x y z rule: ereal3_cases) simp_all
 
 lemma ereal_add_uminus_conv_diff: fixes x y z :: ereal shows "- x + y = y - x"
   by(cases x y rule: ereal2_cases) simp_all
 
 lemma ereal_minus_diff_eq:
   fixes x y :: ereal
   shows "\<lbrakk> x = \<infinity> \<longrightarrow> y \<noteq> \<infinity>; x = -\<infinity> \<longrightarrow> y \<noteq> - \<infinity> \<rbrakk> \<Longrightarrow> - (x - y) = y - x"
   by(cases x y rule: ereal2_cases) simp_all
 
 lemma ediff_le_self [simp]: "x - y \<le> (x :: enat)"
   by(cases x y rule: enat.exhaust[case_product enat.exhaust]) simp_all
 
 lemma ereal_abs_diff:
   fixes a b::ereal
   shows "abs(a-b) \<le> abs a + abs b"
   by (cases rule: ereal2_cases[of a b]) (auto)
 
 
 subsubsection \<open>Division\<close>
 
 instantiation ereal :: inverse
 begin
 
 function inverse_ereal where
   "inverse (ereal r) = (if r = 0 then \<infinity> else ereal (inverse r))"
 | "inverse (\<infinity>::ereal) = 0"
 | "inverse (-\<infinity>::ereal) = 0"
   by (auto intro: ereal_cases)
 termination by (relation "{}") simp
 
 definition "x div y = x * inverse (y :: ereal)"
 
 instance ..
 
 end
 
 lemma real_of_ereal_inverse[simp]:
   fixes a :: ereal
   shows "real_of_ereal (inverse a) = 1 / real_of_ereal a"
   by (cases a) (auto simp: inverse_eq_divide)
 
 lemma ereal_inverse[simp]:
   "inverse (0::ereal) = \<infinity>"
   "inverse (1::ereal) = 1"
   by (simp_all add: one_ereal_def zero_ereal_def)
 
 lemma ereal_divide[simp]:
   "ereal r / ereal p = (if p = 0 then ereal r * \<infinity> else ereal (r / p))"
   unfolding divide_ereal_def by (auto simp: divide_real_def)
 
 lemma ereal_divide_same[simp]:
   fixes x :: ereal
   shows "x / x = (if \<bar>x\<bar> = \<infinity> \<or> x = 0 then 0 else 1)"
   by (cases x) (simp_all add: divide_real_def divide_ereal_def one_ereal_def)
 
 lemma ereal_inv_inv[simp]:
   fixes x :: ereal
   shows "inverse (inverse x) = (if x \<noteq> -\<infinity> then x else \<infinity>)"
   by (cases x) auto
 
 lemma ereal_inverse_minus[simp]:
   fixes x :: ereal
   shows "inverse (- x) = (if x = 0 then \<infinity> else -inverse x)"
   by (cases x) simp_all
 
 lemma ereal_uminus_divide[simp]:
   fixes x y :: ereal
   shows "- x / y = - (x / y)"
   unfolding divide_ereal_def by simp
 
 lemma ereal_divide_Infty[simp]:
   fixes x :: ereal
   shows "x / \<infinity> = 0" "x / -\<infinity> = 0"
   unfolding divide_ereal_def by simp_all
 
 lemma ereal_divide_one[simp]: "x / 1 = (x::ereal)"
   unfolding divide_ereal_def by simp
 
 lemma ereal_divide_ereal[simp]: "\<infinity> / ereal r = (if 0 \<le> r then \<infinity> else -\<infinity>)"
   unfolding divide_ereal_def by simp
 
 lemma ereal_inverse_nonneg_iff: "0 \<le> inverse (x :: ereal) \<longleftrightarrow> 0 \<le> x \<or> x = -\<infinity>"
   by (cases x) auto
 
 lemma inverse_ereal_ge0I: "0 \<le> (x :: ereal) \<Longrightarrow> 0 \<le> inverse x"
 by(cases x) simp_all
 
 lemma zero_le_divide_ereal[simp]:
   fixes a :: ereal
   assumes "0 \<le> a"
     and "0 \<le> b"
   shows "0 \<le> a / b"
   using assms by (cases rule: ereal2_cases[of a b]) (auto simp: zero_le_divide_iff)
 
 lemma ereal_le_divide_pos:
   fixes x y z :: ereal
   shows "x > 0 \<Longrightarrow> x \<noteq> \<infinity> \<Longrightarrow> y \<le> z / x \<longleftrightarrow> x * y \<le> z"
   by (cases rule: ereal3_cases[of x y z]) (auto simp: field_simps)
 
 lemma ereal_divide_le_pos:
   fixes x y z :: ereal
   shows "x > 0 \<Longrightarrow> x \<noteq> \<infinity> \<Longrightarrow> z / x \<le> y \<longleftrightarrow> z \<le> x * y"
   by (cases rule: ereal3_cases[of x y z]) (auto simp: field_simps)
 
 lemma ereal_le_divide_neg:
   fixes x y z :: ereal
   shows "x < 0 \<Longrightarrow> x \<noteq> -\<infinity> \<Longrightarrow> y \<le> z / x \<longleftrightarrow> z \<le> x * y"
   by (cases rule: ereal3_cases[of x y z]) (auto simp: field_simps)
 
 lemma ereal_divide_le_neg:
   fixes x y z :: ereal
   shows "x < 0 \<Longrightarrow> x \<noteq> -\<infinity> \<Longrightarrow> z / x \<le> y \<longleftrightarrow> x * y \<le> z"
   by (cases rule: ereal3_cases[of x y z]) (auto simp: field_simps)
 
 lemma ereal_inverse_antimono_strict:
   fixes x y :: ereal
   shows "0 \<le> x \<Longrightarrow> x < y \<Longrightarrow> inverse y < inverse x"
   by (cases rule: ereal2_cases[of x y]) auto
 
 lemma ereal_inverse_antimono:
   fixes x y :: ereal
   shows "0 \<le> x \<Longrightarrow> x \<le> y \<Longrightarrow> inverse y \<le> inverse x"
   by (cases rule: ereal2_cases[of x y]) auto
 
 lemma inverse_inverse_Pinfty_iff[simp]:
   fixes x :: ereal
   shows "inverse x = \<infinity> \<longleftrightarrow> x = 0"
   by (cases x) auto
 
 lemma ereal_inverse_eq_0:
   fixes x :: ereal
   shows "inverse x = 0 \<longleftrightarrow> x = \<infinity> \<or> x = -\<infinity>"
   by (cases x) auto
 
 lemma ereal_0_gt_inverse:
   fixes x :: ereal
   shows "0 < inverse x \<longleftrightarrow> x \<noteq> \<infinity> \<and> 0 \<le> x"
   by (cases x) auto
 
 lemma ereal_inverse_le_0_iff:
   fixes x :: ereal
   shows "inverse x \<le> 0 \<longleftrightarrow> x < 0 \<or> x = \<infinity>"
   by(cases x) auto
 
 lemma ereal_divide_eq_0_iff: "x / y = 0 \<longleftrightarrow> x = 0 \<or> \<bar>y :: ereal\<bar> = \<infinity>"
 by(cases x y rule: ereal2_cases) simp_all
 
 lemma ereal_mult_less_right:
   fixes a b c :: ereal
   assumes "b * a < c * a"
     and "0 < a"
     and "a < \<infinity>"
   shows "b < c"
   using assms
   by (cases rule: ereal3_cases[of a b c])
      (auto split: if_split_asm simp: zero_less_mult_iff zero_le_mult_iff)
 
 lemma ereal_mult_divide: fixes a b :: ereal shows "0 < b \<Longrightarrow> b < \<infinity> \<Longrightarrow> b * (a / b) = a"
   by (cases a b rule: ereal2_cases) auto
 
 lemma ereal_power_divide:
   fixes x y :: ereal
   shows "y \<noteq> 0 \<Longrightarrow> (x / y) ^ n = x^n / y^n"
   by (cases rule: ereal2_cases [of x y])
      (auto simp: one_ereal_def zero_ereal_def power_divide zero_le_power_eq)
 
 lemma ereal_le_mult_one_interval:
   fixes x y :: ereal
   assumes y: "y \<noteq> -\<infinity>"
   assumes z: "\<And>z. 0 < z \<Longrightarrow> z < 1 \<Longrightarrow> z * x \<le> y"
   shows "x \<le> y"
 proof (cases x)
   case PInf
   with z[of "1 / 2"] show "x \<le> y"
     by (simp add: one_ereal_def)
 next
   case (real r)
   note r = this
   show "x \<le> y"
   proof (cases y)
     case (real p)
     note p = this
     have "r \<le> p"
     proof (rule field_le_mult_one_interval)
       fix z :: real
       assume "0 < z" and "z < 1"
       with z[of "ereal z"] show "z * r \<le> p"
         using p r by (auto simp: zero_le_mult_iff one_ereal_def)
     qed
     then show "x \<le> y"
       using p r by simp
   qed (insert y, simp_all)
 qed simp
 
 lemma ereal_divide_right_mono[simp]:
   fixes x y z :: ereal
   assumes "x \<le> y"
     and "0 < z"
   shows "x / z \<le> y / z"
   using assms by (cases x y z rule: ereal3_cases) (auto intro: divide_right_mono)
 
 lemma ereal_divide_left_mono[simp]:
   fixes x y z :: ereal
   assumes "y \<le> x"
     and "0 < z"
     and "0 < x * y"
   shows "z / x \<le> z / y"
   using assms
   by (cases x y z rule: ereal3_cases)
      (auto intro: divide_left_mono simp: field_simps zero_less_mult_iff mult_less_0_iff split: if_split_asm)
 
 lemma ereal_divide_zero_left[simp]:
   fixes a :: ereal
   shows "0 / a = 0"
   by (cases a) (auto simp: zero_ereal_def)
 
 lemma ereal_times_divide_eq_left[simp]:
   fixes a b c :: ereal
   shows "b / c * a = b * a / c"
   by (cases a b c rule: ereal3_cases) (auto simp: field_simps zero_less_mult_iff mult_less_0_iff)
 
 lemma ereal_times_divide_eq: "a * (b / c :: ereal) = a * b / c"
   by (cases a b c rule: ereal3_cases)
      (auto simp: field_simps zero_less_mult_iff)
 
 lemma ereal_inverse_real [simp]: "\<bar>z\<bar> \<noteq> \<infinity> \<Longrightarrow> z \<noteq> 0 \<Longrightarrow> ereal (inverse (real_of_ereal z)) = inverse z"
   by auto
 
 lemma ereal_inverse_mult:
   "a \<noteq> 0 \<Longrightarrow> b \<noteq> 0 \<Longrightarrow> inverse (a * (b::ereal)) = inverse a * inverse b"
   by (cases a; cases b) auto
 
 lemma inverse_eq_infinity_iff_eq_zero [simp]:
   "1/(x::ereal) = \<infinity> \<longleftrightarrow> x = 0"
 by (simp add: divide_ereal_def)
 
 lemma ereal_distrib_left:
   fixes a b c :: ereal
   assumes "a \<noteq> \<infinity> \<or> b \<noteq> -\<infinity>"
     and "a \<noteq> -\<infinity> \<or> b \<noteq> \<infinity>"
     and "\<bar>c\<bar> \<noteq> \<infinity>"
   shows "c * (a + b) = c * a + c * b"
 using assms
 by (cases rule: ereal3_cases[of a b c]) (simp_all add: field_simps)
 
 lemma ereal_distrib_minus_left:
   fixes a b c :: ereal
   assumes "a \<noteq> \<infinity> \<or> b \<noteq> \<infinity>"
     and "a \<noteq> -\<infinity> \<or> b \<noteq> -\<infinity>"
     and "\<bar>c\<bar> \<noteq> \<infinity>"
   shows "c * (a - b) = c * a - c * b"
 using assms
 by (cases rule: ereal3_cases[of a b c]) (simp_all add: field_simps)
 
 lemma ereal_distrib_minus_right:
   fixes a b c :: ereal
   assumes "a \<noteq> \<infinity> \<or> b \<noteq> \<infinity>"
     and "a \<noteq> -\<infinity> \<or> b \<noteq> -\<infinity>"
     and "\<bar>c\<bar> \<noteq> \<infinity>"
   shows "(a - b) * c = a * c - b * c"
 using assms
 by (cases rule: ereal3_cases[of a b c]) (simp_all add: field_simps)
 
 
 subsection "Complete lattice"
 
 instantiation ereal :: lattice
 begin
 
 definition [simp]: "sup x y = (max x y :: ereal)"
 definition [simp]: "inf x y = (min x y :: ereal)"
 instance by standard simp_all
 
 end
 
 instantiation ereal :: complete_lattice
 begin
 
 definition "bot = (-\<infinity>::ereal)"
 definition "top = (\<infinity>::ereal)"
 
 definition "Sup S = (SOME x :: ereal. (\<forall>y\<in>S. y \<le> x) \<and> (\<forall>z. (\<forall>y\<in>S. y \<le> z) \<longrightarrow> x \<le> z))"
 definition "Inf S = (SOME x :: ereal. (\<forall>y\<in>S. x \<le> y) \<and> (\<forall>z. (\<forall>y\<in>S. z \<le> y) \<longrightarrow> z \<le> x))"
 
 lemma ereal_complete_Sup:
   fixes S :: "ereal set"
   shows "\<exists>x. (\<forall>y\<in>S. y \<le> x) \<and> (\<forall>z. (\<forall>y\<in>S. y \<le> z) \<longrightarrow> x \<le> z)"
 proof (cases "\<exists>x. \<forall>a\<in>S. a \<le> ereal x")
   case True
   then obtain y where y: "a \<le> ereal y" if "a\<in>S" for a
     by auto
   then have "\<infinity> \<notin> S"
     by force
   show ?thesis
   proof (cases "S \<noteq> {-\<infinity>} \<and> S \<noteq> {}")
     case True
     with \<open>\<infinity> \<notin> S\<close> obtain x where x: "x \<in> S" "\<bar>x\<bar> \<noteq> \<infinity>"
       by auto
     obtain s where s: "\<forall>x\<in>ereal -` S. x \<le> s" "(\<forall>x\<in>ereal -` S. x \<le> z) \<Longrightarrow> s \<le> z" for z
     proof (atomize_elim, rule complete_real)
       show "\<exists>x. x \<in> ereal -` S"
         using x by auto
       show "\<exists>z. \<forall>x\<in>ereal -` S. x \<le> z"
         by (auto dest: y intro!: exI[of _ y])
     qed
     show ?thesis
     proof (safe intro!: exI[of _ "ereal s"])
       fix y
       assume "y \<in> S"
       with s \<open>\<infinity> \<notin> S\<close> show "y \<le> ereal s"
         by (cases y) auto
     next
       fix z
       assume "\<forall>y\<in>S. y \<le> z"
       with \<open>S \<noteq> {-\<infinity>} \<and> S \<noteq> {}\<close> show "ereal s \<le> z"
         by (cases z) (auto intro!: s)
     qed
   next
     case False
     then show ?thesis
       by (auto intro!: exI[of _ "-\<infinity>"])
   qed
 next
   case False
   then show ?thesis
     by (fastforce intro!: exI[of _ \<infinity>] ereal_top intro: order_trans dest: less_imp_le simp: not_le)
 qed
 
 lemma ereal_complete_uminus_eq:
   fixes S :: "ereal set"
   shows "(\<forall>y\<in>uminus`S. y \<le> x) \<and> (\<forall>z. (\<forall>y\<in>uminus`S. y \<le> z) \<longrightarrow> x \<le> z)
      \<longleftrightarrow> (\<forall>y\<in>S. -x \<le> y) \<and> (\<forall>z. (\<forall>y\<in>S. z \<le> y) \<longrightarrow> z \<le> -x)"
   by simp (metis ereal_minus_le_minus ereal_uminus_uminus)
 
 lemma ereal_complete_Inf:
   "\<exists>x. (\<forall>y\<in>S::ereal set. x \<le> y) \<and> (\<forall>z. (\<forall>y\<in>S. z \<le> y) \<longrightarrow> z \<le> x)"
   using ereal_complete_Sup[of "uminus ` S"]
   unfolding ereal_complete_uminus_eq
   by auto
 
 instance
 proof
   show "Sup {} = (bot::ereal)"
     using ereal_bot by (auto simp: bot_ereal_def Sup_ereal_def)
   show "Inf {} = (top::ereal)"
     unfolding top_ereal_def Inf_ereal_def
     using ereal_infty_less_eq(1) ereal_less_eq(1) by blast
 qed (auto intro: someI2_ex ereal_complete_Sup ereal_complete_Inf
   simp: Sup_ereal_def Inf_ereal_def bot_ereal_def top_ereal_def)
 
 end
 
 instance ereal :: complete_linorder ..
 
 instance ereal :: linear_continuum
 proof
   show "\<exists>a b::ereal. a \<noteq> b"
     using zero_neq_one by blast
 qed
 
 lemma min_PInf [simp]: "min (\<infinity>::ereal) x = x"
   by (metis min_top top_ereal_def)
 
 lemma min_PInf2 [simp]: "min x (\<infinity>::ereal) = x"
   by (metis min_top2 top_ereal_def)
 
 lemma max_PInf [simp]: "max (\<infinity>::ereal) x = \<infinity>"
   by (metis max_top top_ereal_def)
 
 lemma max_PInf2 [simp]: "max x (\<infinity>::ereal) = \<infinity>"
   by (metis max_top2 top_ereal_def)
 
 lemma min_MInf [simp]: "min (-\<infinity>::ereal) x = -\<infinity>"
   by (metis min_bot bot_ereal_def)
 
 lemma min_MInf2 [simp]: "min x (-\<infinity>::ereal) = -\<infinity>"
   by (metis min_bot2 bot_ereal_def)
 
 lemma max_MInf [simp]: "max (-\<infinity>::ereal) x = x"
   by (metis max_bot bot_ereal_def)
 
 lemma max_MInf2 [simp]: "max x (-\<infinity>::ereal) = x"
   by (metis max_bot2 bot_ereal_def)
 
 subsection \<open>Extended real intervals\<close>
 
 lemma real_greaterThanLessThan_infinity_eq:
   "real_of_ereal ` {N::ereal<..<\<infinity>} =
     (if N = \<infinity> then {} else if N = -\<infinity> then UNIV else {real_of_ereal N<..})"
   by (force simp: real_less_ereal_iff intro!: image_eqI[where x="ereal _"] elim!: less_ereal.elims)
 
 lemma real_greaterThanLessThan_minus_infinity_eq:
   "real_of_ereal ` {-\<infinity><..<N::ereal} =
     (if N = \<infinity> then UNIV else if N = -\<infinity> then {} else {..<real_of_ereal N})"
 proof -
   have "real_of_ereal ` {-\<infinity><..<N::ereal} = uminus ` real_of_ereal ` {-N<..<\<infinity>}"
     by (auto simp: ereal_uminus_less_reorder intro!: image_eqI[where x="-x" for x])
   also note real_greaterThanLessThan_infinity_eq
   finally show ?thesis by (auto intro!: image_eqI[where x="-x" for x])
 qed
 
 lemma real_greaterThanLessThan_inter:
   "real_of_ereal ` {N<..<M::ereal} = real_of_ereal ` {-\<infinity><..<M} \<inter> real_of_ereal ` {N<..<\<infinity>}"
   by (force elim!: less_ereal.elims)
 
 lemma real_atLeastGreaterThan_eq: "real_of_ereal ` {N<..<M::ereal} =
    (if N = \<infinity> then {} else
    if N = -\<infinity> then
     (if M = \<infinity> then UNIV
     else if M = -\<infinity> then {}
     else {..< real_of_ereal M})
   else if M = - \<infinity> then {}
   else if M = \<infinity> then {real_of_ereal N<..}
   else {real_of_ereal N <..< real_of_ereal M})"
 proof (cases "M = -\<infinity> \<or> M = \<infinity> \<or> N = -\<infinity> \<or> N = \<infinity>")
   case True
   then show ?thesis
     by (auto simp: real_greaterThanLessThan_minus_infinity_eq real_greaterThanLessThan_infinity_eq )
 next
   case False
   then obtain p q where "M = ereal p" "N = ereal q"
     by (metis MInfty_eq_minfinity ereal.distinct(3) uminus_ereal.elims)
   moreover have "\<And>x. \<lbrakk>q < x; x < p\<rbrakk> \<Longrightarrow> x \<in> real_of_ereal ` {ereal q<..<ereal p}"
     by (metis greaterThanLessThan_iff imageI less_ereal.simps(1) real_of_ereal.simps(1))
   ultimately show ?thesis 
     by (auto elim!: less_ereal.elims)
 qed
 
 lemma real_image_ereal_ivl:
   fixes a b::ereal
   shows
   "real_of_ereal ` {a<..<b} =
   (if a < b then (if a = - \<infinity> then if b = \<infinity> then UNIV else {..<real_of_ereal b}
   else if b = \<infinity> then {real_of_ereal a<..} else {real_of_ereal a <..< real_of_ereal b}) else {})"
   by (cases a; cases b; simp add: real_atLeastGreaterThan_eq not_less)
 
 lemma fixes a b c::ereal
   shows not_inftyI: "a < b \<Longrightarrow> b < c \<Longrightarrow> abs b \<noteq> \<infinity>"
   by force
 
 lemma
   interval_neqs:
   fixes r s t::real
   shows "{r<..<s} \<noteq> {t<..}"
     and "{r<..<s} \<noteq> {..<t}"
     and "{r<..<ra} \<noteq> UNIV"
     and "{r<..} \<noteq> {..<s}"
     and "{r<..} \<noteq> UNIV"
     and "{..<r} \<noteq> UNIV"
     and "{} \<noteq> {r<..}"
     and "{} \<noteq> {..<r}"
   subgoal
     by (metis dual_order.strict_trans greaterThanLessThan_iff greaterThan_iff gt_ex not_le order_refl)
   subgoal
     by (metis (no_types, opaque_lifting) greaterThanLessThan_empty_iff greaterThanLessThan_iff gt_ex
         lessThan_iff minus_minus neg_less_iff_less not_less order_less_irrefl)
   subgoal by force
   subgoal
     by (metis greaterThanLessThan_empty_iff greaterThanLessThan_eq greaterThan_iff inf.idem
         lessThan_iff lessThan_non_empty less_irrefl not_le)
   subgoal by force
   subgoal by force
   subgoal using greaterThan_non_empty by blast
   subgoal using lessThan_non_empty by blast
   done
 
 lemma greaterThanLessThan_eq_iff:
   fixes r s t u::real
   shows "({r<..<s} = {t<..<u}) = (r \<ge> s \<and> u \<le> t \<or> r = t \<and> s = u)"
   by (metis cInf_greaterThanLessThan cSup_greaterThanLessThan greaterThanLessThan_empty_iff not_le)
 
 lemma real_of_ereal_image_greaterThanLessThan_iff:
   "real_of_ereal ` {a <..< b} = real_of_ereal ` {c <..< d} \<longleftrightarrow> (a \<ge> b \<and> c \<ge> d \<or> a = c \<and> b = d)"
   unfolding real_atLeastGreaterThan_eq
   by (cases a; cases b; cases c; cases d;
     simp add: greaterThanLessThan_eq_iff interval_neqs interval_neqs[symmetric])
 
 lemma uminus_image_real_of_ereal_image_greaterThanLessThan:
   "uminus ` real_of_ereal ` {l <..< u} = real_of_ereal ` {-u <..< -l}"
   by (force simp: algebra_simps ereal_less_uminus_reorder
     ereal_uminus_less_reorder intro: image_eqI[where x="-x" for x])
 
 lemma add_image_real_of_ereal_image_greaterThanLessThan:
   "(+) c ` real_of_ereal ` {l <..< u} = real_of_ereal ` {c + l <..< c + u}"
   apply safe
   subgoal for x
     using ereal_less_add[of c]
     by (force simp: real_of_ereal_add add.commute)
   subgoal for _ x
     by (force simp: add.commute real_of_ereal_minus ereal_minus_less ereal_less_minus
       intro: image_eqI[where x="x - c"])
   done
 
 lemma add2_image_real_of_ereal_image_greaterThanLessThan:
   "(\<lambda>x. x + c) ` real_of_ereal ` {l <..< u} = real_of_ereal ` {l + c <..< u + c}"
   using add_image_real_of_ereal_image_greaterThanLessThan[of c l u]
   by (metis add.commute image_cong)
 
 lemma minus_image_real_of_ereal_image_greaterThanLessThan:
   "(-) c ` real_of_ereal ` {l <..< u} = real_of_ereal ` {c - u <..< c - l}"
   (is "?l = ?r")
 proof -
   have "?l = (+) c ` uminus ` real_of_ereal ` {l <..< u}" by auto
   also note uminus_image_real_of_ereal_image_greaterThanLessThan
   also note add_image_real_of_ereal_image_greaterThanLessThan
   finally show ?thesis by (simp add: minus_ereal_def)
 qed
 
 lemma real_ereal_bound_lemma_up:
   assumes "s \<in> real_of_ereal ` {a<..<b}"
   assumes "t \<notin> real_of_ereal ` {a<..<b}"
   assumes "s \<le> t"
   shows "b \<noteq> \<infinity>"
 proof (cases b)
   case PInf
   then show ?thesis
     using assms
     apply clarsimp
     by (metis UNIV_I assms(1) ereal_less_PInfty greaterThan_iff less_eq_ereal_def less_le_trans real_image_ereal_ivl)
 qed auto
 
 lemma real_ereal_bound_lemma_down:
   assumes s: "s \<in> real_of_ereal ` {a<..<b}"
   and t: "t \<notin> real_of_ereal ` {a<..<b}"
   and "t \<le> s"
   shows "a \<noteq> - \<infinity>"
 proof (cases b)
   case (real r)
   then show ?thesis
     using assms real_greaterThanLessThan_minus_infinity_eq by force
 next
   case PInf
   then show ?thesis
     using t real_greaterThanLessThan_infinity_eq by auto
 next
   case MInf
   then show ?thesis
     using s by auto
 qed
 
 
 subsection "Topological space"
 
 instantiation ereal :: linear_continuum_topology
 begin
 
 definition "open_ereal" :: "ereal set \<Rightarrow> bool" where
   open_ereal_generated: "open_ereal = generate_topology (range lessThan \<union> range greaterThan)"
 
 instance
   by standard (simp add: open_ereal_generated)
 
 end
 
 lemma continuous_on_ereal[continuous_intros]:
   assumes f: "continuous_on s f" shows "continuous_on s (\<lambda>x. ereal (f x))"
   by (rule continuous_on_compose2 [OF continuous_onI_mono[of ereal UNIV] f]) auto
 
 lemma tendsto_ereal[tendsto_intros, simp, intro]: "(f \<longlongrightarrow> x) F \<Longrightarrow> ((\<lambda>x. ereal (f x)) \<longlongrightarrow> ereal x) F"
   using isCont_tendsto_compose[of x ereal f F] continuous_on_ereal[of UNIV "\<lambda>x. x"]
   by (simp add: continuous_on_eq_continuous_at)
 
 lemma tendsto_uminus_ereal[tendsto_intros, simp, intro]:
   assumes "(f \<longlongrightarrow> x) F"
   shows "((\<lambda>x. - f x::ereal) \<longlongrightarrow> - x) F"
 proof (rule tendsto_compose[OF order_tendstoI assms])
   show "\<And>a. a < - x \<Longrightarrow> \<forall>\<^sub>F x in at x. a < - x"
     by (metis ereal_less_uminus_reorder eventually_at_topological lessThan_iff open_lessThan)
   show "\<And>a. - x < a \<Longrightarrow> \<forall>\<^sub>F x in at x. - x < a"
     by (metis ereal_uminus_reorder(2) eventually_at_topological greaterThan_iff open_greaterThan)
 qed
 
 lemma at_infty_ereal_eq_at_top: "at \<infinity> = filtermap ereal at_top"
   unfolding filter_eq_iff eventually_at_filter eventually_at_top_linorder eventually_filtermap
     top_ereal_def[symmetric]
   apply (subst eventually_nhds_top[of 0])
   apply (auto simp: top_ereal_def less_le ereal_all_split ereal_ex_split)
   apply (metis PInfty_neq_ereal(2) ereal_less_eq(3) ereal_top le_cases order_trans)
   done
 
 lemma ereal_Lim_uminus: "(f \<longlongrightarrow> f0) net \<longleftrightarrow> ((\<lambda>x. - f x::ereal) \<longlongrightarrow> - f0) net"
   using tendsto_uminus_ereal[of f f0 net] tendsto_uminus_ereal[of "\<lambda>x. - f x" "- f0" net]
   by auto
 
 lemma ereal_divide_less_iff: "0 < (c::ereal) \<Longrightarrow> c < \<infinity> \<Longrightarrow> a / c < b \<longleftrightarrow> a < b * c"
   by (cases a b c rule: ereal3_cases) (auto simp: field_simps)
 
 lemma ereal_less_divide_iff: "0 < (c::ereal) \<Longrightarrow> c < \<infinity> \<Longrightarrow> a < b / c \<longleftrightarrow> a * c < b"
   by (cases a b c rule: ereal3_cases) (auto simp: field_simps)
 
 lemma tendsto_cmult_ereal[tendsto_intros, simp, intro]:
   assumes c: "\<bar>c\<bar> \<noteq> \<infinity>" and f: "(f \<longlongrightarrow> x) F" shows "((\<lambda>x. c * f x::ereal) \<longlongrightarrow> c * x) F"
 proof -
   { fix c :: ereal assume "0 < c" "c < \<infinity>"
     then have "((\<lambda>x. c * f x::ereal) \<longlongrightarrow> c * x) F"
       apply (intro tendsto_compose[OF _ f])
       apply (auto intro!: order_tendstoI simp: eventually_at_topological)
       apply (rule_tac x="{a/c <..}" in exI)
       apply (auto split: ereal.split simp: ereal_divide_less_iff mult.commute) []
       apply (rule_tac x="{..< a/c}" in exI)
       apply (auto split: ereal.split simp: ereal_less_divide_iff mult.commute) []
       done }
   note * = this
 
   have "((0 < c \<and> c < \<infinity>) \<or> (-\<infinity> < c \<and> c < 0) \<or> c = 0)"
     using c by (cases c) auto
   then show ?thesis
   proof (elim disjE conjE)
     assume "- \<infinity> < c" "c < 0"
     then have "0 < - c" "- c < \<infinity>"
       by (auto simp: ereal_uminus_reorder ereal_less_uminus_reorder[of 0])
     then have "((\<lambda>x. (- c) * f x) \<longlongrightarrow> (- c) * x) F"
       by (rule *)
     from tendsto_uminus_ereal[OF this] show ?thesis
       by simp
   qed (auto intro!: *)
 qed
 
 lemma tendsto_cmult_ereal_not_0[tendsto_intros, simp, intro]:
   assumes "x \<noteq> 0" and f: "(f \<longlongrightarrow> x) F" shows "((\<lambda>x. c * f x::ereal) \<longlongrightarrow> c * x) F"
 proof cases
   assume "\<bar>c\<bar> = \<infinity>"
   show ?thesis
   proof (rule filterlim_cong[THEN iffD1, OF refl refl _ tendsto_const])
     have "0 < x \<or> x < 0"
       using \<open>x \<noteq> 0\<close> by (auto simp add: neq_iff)
     then show "eventually (\<lambda>x'. c * x = c * f x') F"
     proof
       assume "0 < x" from order_tendstoD(1)[OF f this] show ?thesis
         by eventually_elim (insert \<open>0<x\<close> \<open>\<bar>c\<bar> = \<infinity>\<close>, auto)
     next
       assume "x < 0" from order_tendstoD(2)[OF f this] show ?thesis
         by eventually_elim (insert \<open>x<0\<close> \<open>\<bar>c\<bar> = \<infinity>\<close>, auto)
     qed
   qed
 qed (rule tendsto_cmult_ereal[OF _ f])
 
 lemma tendsto_cadd_ereal[tendsto_intros, simp, intro]:
   assumes c: "y \<noteq> - \<infinity>" "x \<noteq> - \<infinity>" and f: "(f \<longlongrightarrow> x) F" shows "((\<lambda>x. f x + y::ereal) \<longlongrightarrow> x + y) F"
   apply (intro tendsto_compose[OF _ f])
   apply (auto intro!: order_tendstoI simp: eventually_at_topological)
   apply (rule_tac x="{a - y <..}" in exI)
   apply (auto split: ereal.split simp: ereal_minus_less_iff c) []
   apply (rule_tac x="{..< a - y}" in exI)
   apply (auto split: ereal.split simp: ereal_less_minus_iff c) []
   done
 
 lemma tendsto_add_left_ereal[tendsto_intros, simp, intro]:
   assumes c: "\<bar>y\<bar> \<noteq> \<infinity>" and f: "(f \<longlongrightarrow> x) F" shows "((\<lambda>x. f x + y::ereal) \<longlongrightarrow> x + y) F"
   apply (intro tendsto_compose[OF _ f])
   apply (auto intro!: order_tendstoI simp: eventually_at_topological)
   apply (rule_tac x="{a - y <..}" in exI)
   apply (insert c, auto split: ereal.split simp: ereal_minus_less_iff) []
   apply (rule_tac x="{..< a - y}" in exI)
   apply (auto split: ereal.split simp: ereal_less_minus_iff c) []
   done
 
 lemma continuous_at_ereal[continuous_intros]: "continuous F f \<Longrightarrow> continuous F (\<lambda>x. ereal (f x))"
   unfolding continuous_def by auto
 
 lemma ereal_Sup:
   assumes *: "\<bar>SUP a\<in>A. ereal a\<bar> \<noteq> \<infinity>"
   shows "ereal (Sup A) = (SUP a\<in>A. ereal a)"
 proof (rule continuous_at_Sup_mono)
   obtain r where r: "ereal r = (SUP a\<in>A. ereal a)" "A \<noteq> {}"
     using * by (force simp: bot_ereal_def)
   then show "bdd_above A" "A \<noteq> {}"
     by (auto intro!: SUP_upper bdd_aboveI[of _ r] simp flip: ereal_less_eq)
 qed (auto simp: mono_def continuous_at_imp_continuous_at_within continuous_at_ereal)
 
 lemma ereal_SUP: "\<bar>SUP a\<in>A. ereal (f a)\<bar> \<noteq> \<infinity> \<Longrightarrow> ereal (SUP a\<in>A. f a) = (SUP a\<in>A. ereal (f a))"
   by (simp add: ereal_Sup image_comp)
 
 lemma ereal_Inf:
   assumes *: "\<bar>INF a\<in>A. ereal a\<bar> \<noteq> \<infinity>"
   shows "ereal (Inf A) = (INF a\<in>A. ereal a)"
 proof (rule continuous_at_Inf_mono)
   obtain r where r: "ereal r = (INF a\<in>A. ereal a)" "A \<noteq> {}"
     using * by (force simp: top_ereal_def)
   then show "bdd_below A" "A \<noteq> {}"
     by (auto intro!: INF_lower bdd_belowI[of _ r] simp flip: ereal_less_eq)
 qed (auto simp: mono_def continuous_at_imp_continuous_at_within continuous_at_ereal)
 
 lemma ereal_Inf':
   assumes *: "bdd_below A" "A \<noteq> {}"
   shows "ereal (Inf A) = (INF a\<in>A. ereal a)"
 proof (rule ereal_Inf)
   from * obtain l u where "x \<in> A \<Longrightarrow> l \<le> x" "u \<in> A" for x
     by (auto simp: bdd_below_def)
   then have "l \<le> (INF x\<in>A. ereal x)" "(INF x\<in>A. ereal x) \<le> u"
     by (auto intro!: INF_greatest INF_lower)
   then show "\<bar>INF a\<in>A. ereal a\<bar> \<noteq> \<infinity>"
     by auto
 qed
 
 lemma ereal_INF: "\<bar>INF a\<in>A. ereal (f a)\<bar> \<noteq> \<infinity> \<Longrightarrow> ereal (INF a\<in>A. f a) = (INF a\<in>A. ereal (f a))"
   by (simp add: ereal_Inf image_comp)
 
 lemma ereal_Sup_uminus_image_eq: "Sup (uminus ` S::ereal set) = - Inf S"
   by (auto intro!: SUP_eqI
            simp: Ball_def[symmetric] ereal_uminus_le_reorder le_Inf_iff
            intro!: complete_lattice_class.Inf_lower2)
 
 lemma ereal_SUP_uminus_eq:
   fixes f :: "'a \<Rightarrow> ereal"
   shows "(SUP x\<in>S. uminus (f x)) = - (INF x\<in>S. f x)"
   using ereal_Sup_uminus_image_eq [of "f ` S"] by (simp add: image_comp)
 
 lemma ereal_inj_on_uminus[intro, simp]: "inj_on uminus (A :: ereal set)"
   by (auto intro!: inj_onI)
 
 lemma ereal_Inf_uminus_image_eq: "Inf (uminus ` S::ereal set) = - Sup S"
   using ereal_Sup_uminus_image_eq[of "uminus ` S"] by simp
 
 lemma ereal_INF_uminus_eq:
   fixes f :: "'a \<Rightarrow> ereal"
   shows "(INF x\<in>S. - f x) = - (SUP x\<in>S. f x)"
   using ereal_Inf_uminus_image_eq [of "f ` S"] by (simp add: image_comp)
 
 lemma ereal_SUP_uminus:
   fixes f :: "'a \<Rightarrow> ereal"
   shows "(SUP i \<in> R. - f i) = - (INF i \<in> R. f i)"
   using ereal_Sup_uminus_image_eq[of "f`R"]
   by (simp add: image_image)
 
 lemma ereal_SUP_not_infty:
   fixes f :: "_ \<Rightarrow> ereal"
   shows "A \<noteq> {} \<Longrightarrow> l \<noteq> -\<infinity> \<Longrightarrow> u \<noteq> \<infinity> \<Longrightarrow> \<forall>a\<in>A. l \<le> f a \<and> f a \<le> u \<Longrightarrow> \<bar>Sup (f ` A)\<bar> \<noteq> \<infinity>"
   using SUP_upper2[of _ A l f] SUP_least[of A f u]
   by (cases "Sup (f ` A)") auto
 
 lemma ereal_INF_not_infty:
   fixes f :: "_ \<Rightarrow> ereal"
   shows "A \<noteq> {} \<Longrightarrow> l \<noteq> -\<infinity> \<Longrightarrow> u \<noteq> \<infinity> \<Longrightarrow> \<forall>a\<in>A. l \<le> f a \<and> f a \<le> u \<Longrightarrow> \<bar>Inf (f ` A)\<bar> \<noteq> \<infinity>"
   using INF_lower2[of _ A f u] INF_greatest[of A l f]
   by (cases "Inf (f ` A)") auto
 
 lemma ereal_image_uminus_shift:
   fixes X Y :: "ereal set"
   shows "uminus ` X = Y \<longleftrightarrow> X = uminus ` Y"
 proof
   assume "uminus ` X = Y"
   then have "uminus ` uminus ` X = uminus ` Y"
     by (simp add: inj_image_eq_iff)
   then show "X = uminus ` Y"
     by (simp add: image_image)
 qed (simp add: image_image)
 
 lemma Sup_eq_MInfty:
   fixes S :: "ereal set"
   shows "Sup S = -\<infinity> \<longleftrightarrow> S = {} \<or> S = {-\<infinity>}"
   unfolding bot_ereal_def[symmetric] by auto
 
 lemma Inf_eq_PInfty:
   fixes S :: "ereal set"
   shows "Inf S = \<infinity> \<longleftrightarrow> S = {} \<or> S = {\<infinity>}"
   using Sup_eq_MInfty[of "uminus`S"]
   unfolding ereal_Sup_uminus_image_eq ereal_image_uminus_shift by simp
 
 lemma Inf_eq_MInfty:
   fixes S :: "ereal set"
   shows "-\<infinity> \<in> S \<Longrightarrow> Inf S = -\<infinity>"
   unfolding bot_ereal_def[symmetric] by auto
 
 lemma Sup_eq_PInfty:
   fixes S :: "ereal set"
   shows "\<infinity> \<in> S \<Longrightarrow> Sup S = \<infinity>"
   unfolding top_ereal_def[symmetric] by auto
 
 lemma not_MInfty_nonneg[simp]: "0 \<le> (x::ereal) \<Longrightarrow> x \<noteq> - \<infinity>"
   by auto
 
 lemma Sup_ereal_close:
   fixes e :: ereal
   assumes "0 < e"
     and S: "\<bar>Sup S\<bar> \<noteq> \<infinity>" "S \<noteq> {}"
   shows "\<exists>x\<in>S. Sup S - e < x"
   using assms by (cases e) (auto intro!: less_Sup_iff[THEN iffD1])
 
 lemma Inf_ereal_close:
   fixes e :: ereal
   assumes "\<bar>Inf X\<bar> \<noteq> \<infinity>"
     and "0 < e"
   shows "\<exists>x\<in>X. x < Inf X + e"
 proof (rule Inf_less_iff[THEN iffD1])
   show "Inf X < Inf X + e"
     using assms by (cases e) auto
 qed
 
 lemma SUP_PInfty:
   "(\<And>n::nat. \<exists>i\<in>A. ereal (real n) \<le> f i) \<Longrightarrow> (SUP i\<in>A. f i :: ereal) = \<infinity>"
   unfolding top_ereal_def[symmetric] SUP_eq_top_iff
   by (metis MInfty_neq_PInfty(2) PInfty_neq_ereal(2) less_PInf_Ex_of_nat less_ereal.elims(2) less_le_trans)
 
 lemma SUP_nat_Infty: "(SUP i. ereal (real i)) = \<infinity>"
   by (rule SUP_PInfty) auto
 
 lemma SUP_ereal_add_left:
   assumes "I \<noteq> {}" "c \<noteq> -\<infinity>"
   shows "(SUP i\<in>I. f i + c :: ereal) = (SUP i\<in>I. f i) + c"
 proof (cases "(SUP i\<in>I. f i) = - \<infinity>")
   case True
   then have "\<And>i. i \<in> I \<Longrightarrow> f i = -\<infinity>"
     unfolding Sup_eq_MInfty by auto
   with True show ?thesis
     by (cases c) (auto simp: \<open>I \<noteq> {}\<close>)
 next
   case False
   then show ?thesis
     by (subst continuous_at_Sup_mono[where f="\<lambda>x. x + c"])
       (auto simp: continuous_at_imp_continuous_at_within continuous_at mono_def add_mono \<open>I \<noteq> {}\<close>
       \<open>c \<noteq> -\<infinity>\<close> image_comp)
 qed
 
 lemma SUP_ereal_add_right:
   fixes c :: ereal
   shows "I \<noteq> {} \<Longrightarrow> c \<noteq> -\<infinity> \<Longrightarrow> (SUP i\<in>I. c + f i) = c + (SUP i\<in>I. f i)"
   using SUP_ereal_add_left[of I c f] by (simp add: add.commute)
 
 lemma SUP_ereal_minus_right:
   assumes "I \<noteq> {}" "c \<noteq> -\<infinity>"
   shows "(SUP i\<in>I. c - f i :: ereal) = c - (INF i\<in>I. f i)"
   using SUP_ereal_add_right[OF assms, of "\<lambda>i. - f i"]
   by (simp add: ereal_SUP_uminus minus_ereal_def)
 
 lemma SUP_ereal_minus_left:
   assumes "I \<noteq> {}" "c \<noteq> \<infinity>"
   shows "(SUP i\<in>I. f i - c:: ereal) = (SUP i\<in>I. f i) - c"
   using SUP_ereal_add_left[OF \<open>I \<noteq> {}\<close>, of "-c" f] by (simp add: \<open>c \<noteq> \<infinity>\<close> minus_ereal_def)
 
 lemma INF_ereal_minus_right:
   assumes "I \<noteq> {}" and "\<bar>c\<bar> \<noteq> \<infinity>"
   shows "(INF i\<in>I. c - f i) = c - (SUP i\<in>I. f i::ereal)"
 proof -
   { fix b have "(-c) + b = - (c - b)"
       using \<open>\<bar>c\<bar> \<noteq> \<infinity>\<close> by (cases c b rule: ereal2_cases) auto }
   note * = this
   show ?thesis
     using SUP_ereal_add_right[OF \<open>I \<noteq> {}\<close>, of "-c" f] \<open>\<bar>c\<bar> \<noteq> \<infinity>\<close>
     by (auto simp add: * ereal_SUP_uminus_eq)
 qed
 
 lemma SUP_ereal_le_addI:
   fixes f :: "'i \<Rightarrow> ereal"
   assumes "\<And>i. f i + y \<le> z" and "y \<noteq> -\<infinity>"
   shows "Sup (f ` UNIV) + y \<le> z"
   unfolding SUP_ereal_add_left[OF UNIV_not_empty \<open>y \<noteq> -\<infinity>\<close>, symmetric]
   by (rule SUP_least assms)+
 
 lemma SUP_combine:
   fixes f :: "'a::semilattice_sup \<Rightarrow> 'a::semilattice_sup \<Rightarrow> 'b::complete_lattice"
   assumes mono: "\<And>a b c d. a \<le> b \<Longrightarrow> c \<le> d \<Longrightarrow> f a c \<le> f b d"
   shows "(SUP i\<in>UNIV. SUP j\<in>UNIV. f i j) = (SUP i. f i i)"
 proof (rule antisym)
   show "(SUP i j. f i j) \<le> (SUP i. f i i)"
     by (rule SUP_least SUP_upper2[where i="sup i j" for i j] UNIV_I mono sup_ge1 sup_ge2)+
   show "(SUP i. f i i) \<le> (SUP i j. f i j)"
     by (rule SUP_least SUP_upper2 UNIV_I mono order_refl)+
 qed
 
 lemma SUP_ereal_add:
   fixes f g :: "nat \<Rightarrow> ereal"
   assumes inc: "incseq f" "incseq g"
     and pos: "\<And>i. f i \<noteq> -\<infinity>" "\<And>i. g i \<noteq> -\<infinity>"
   shows "(SUP i. f i + g i) = Sup (f ` UNIV) + Sup (g ` UNIV)"
   apply (subst SUP_ereal_add_left[symmetric, OF UNIV_not_empty])
    apply (metis SUP_upper UNIV_I assms(4) ereal_infty_less_eq(2))
   apply (subst (2) add.commute)
   apply (subst SUP_ereal_add_left[symmetric, OF UNIV_not_empty assms(3)])
   apply (subst (2) add.commute)
   apply (rule SUP_combine[symmetric] add_mono inc[THEN monoD] | assumption)+
   done
 
 lemma INF_eq_minf: "(INF i\<in>I. f i::ereal) \<noteq> -\<infinity> \<longleftrightarrow> (\<exists>b>-\<infinity>. \<forall>i\<in>I. b \<le> f i)"
   unfolding bot_ereal_def[symmetric] INF_eq_bot_iff by (auto simp: not_less)
 
 lemma INF_ereal_add_left:
   assumes "I \<noteq> {}" "c \<noteq> -\<infinity>" "\<And>x. x \<in> I \<Longrightarrow> 0 \<le> f x"
   shows "(INF i\<in>I. f i + c :: ereal) = (INF i\<in>I. f i) + c"
 proof -
   have "(INF i\<in>I. f i) \<noteq> -\<infinity>"
     unfolding INF_eq_minf using assms by (intro exI[of _ 0]) auto
   then show ?thesis
     by (subst continuous_at_Inf_mono[where f="\<lambda>x. x + c"])
        (auto simp: mono_def add_mono \<open>I \<noteq> {}\<close> \<open>c \<noteq> -\<infinity>\<close> continuous_at_imp_continuous_at_within
         continuous_at image_comp)
 qed
 
 lemma INF_ereal_add_right:
   assumes "I \<noteq> {}" "c \<noteq> -\<infinity>" "\<And>x. x \<in> I \<Longrightarrow> 0 \<le> f x"
   shows "(INF i\<in>I. c + f i :: ereal) = c + (INF i\<in>I. f i)"
   using INF_ereal_add_left[OF assms] by (simp add: ac_simps)
 
 lemma INF_ereal_add_directed:
   fixes f g :: "'a \<Rightarrow> ereal"
   assumes nonneg: "\<And>i. i \<in> I \<Longrightarrow> 0 \<le> f i" "\<And>i. i \<in> I \<Longrightarrow> 0 \<le> g i"
   assumes directed: "\<And>i j. i \<in> I \<Longrightarrow> j \<in> I \<Longrightarrow> \<exists>k\<in>I. f i + g j \<ge> f k + g k"
   shows "(INF i\<in>I. f i + g i) = (INF i\<in>I. f i) + (INF i\<in>I. g i)"
 proof cases
   assume "I = {}" then show ?thesis
     by (simp add: top_ereal_def)
 next
   assume "I \<noteq> {}"
   show ?thesis
   proof (rule antisym)
     show "(INF i\<in>I. f i) + (INF i\<in>I. g i) \<le> (INF i\<in>I. f i + g i)"
       by (rule INF_greatest; intro add_mono INF_lower)
   next
     have "(INF i\<in>I. f i + g i) \<le> (INF i\<in>I. (INF j\<in>I. f i + g j))"
       using directed by (intro INF_greatest) (blast intro: INF_lower2)
     also have "\<dots> = (INF i\<in>I. f i + (INF i\<in>I. g i))"
       using nonneg \<open>I \<noteq> {}\<close> by (auto simp: INF_ereal_add_right)
     also have "\<dots> = (INF i\<in>I. f i) + (INF i\<in>I. g i)"
       using nonneg by (intro INF_ereal_add_left \<open>I \<noteq> {}\<close>) (auto simp: INF_eq_minf intro!: exI[of _ 0])
     finally show "(INF i\<in>I. f i + g i) \<le> (INF i\<in>I. f i) + (INF i\<in>I. g i)" .
   qed
 qed
 
 lemma INF_ereal_add:
   fixes f :: "nat \<Rightarrow> ereal"
   assumes "decseq f" "decseq g"
     and fin: "\<And>i. f i \<noteq> \<infinity>" "\<And>i. g i \<noteq> \<infinity>"
   shows "(INF i. f i + g i) = Inf (f ` UNIV) + Inf (g ` UNIV)"
 proof -
   have INF_less: "(INF i. f i) < \<infinity>" "(INF i. g i) < \<infinity>"
     using assms unfolding INF_less_iff by auto
   { fix a b :: ereal assume "a \<noteq> \<infinity>" "b \<noteq> \<infinity>"
     then have "- ((- a) + (- b)) = a + b"
       by (cases a b rule: ereal2_cases) auto }
   note * = this
   have "(INF i. f i + g i) = (INF i. - ((- f i) + (- g i)))"
     by (simp add: fin *)
   also have "\<dots> = Inf (f ` UNIV) + Inf (g ` UNIV)"
     unfolding ereal_INF_uminus_eq
     using assms INF_less
     by (subst SUP_ereal_add) (auto simp: ereal_SUP_uminus fin *)
   finally show ?thesis .
 qed
 
 lemma SUP_ereal_add_pos:
   fixes f g :: "nat \<Rightarrow> ereal"
   assumes inc: "incseq f" "incseq g"
     and pos: "\<And>i. 0 \<le> f i" "\<And>i. 0 \<le> g i"
   shows "(SUP i. f i + g i) = Sup (f ` UNIV) + Sup (g ` UNIV)"
 proof (intro SUP_ereal_add inc)
   fix i
   show "f i \<noteq> -\<infinity>" "g i \<noteq> -\<infinity>"
     using pos[of i] by auto
 qed
 
 lemma SUP_ereal_sum:
   fixes f g :: "'a \<Rightarrow> nat \<Rightarrow> ereal"
   assumes "\<And>n. n \<in> A \<Longrightarrow> incseq (f n)"
     and pos: "\<And>n i. n \<in> A \<Longrightarrow> 0 \<le> f n i"
   shows "(SUP i. \<Sum>n\<in>A. f n i) = (\<Sum>n\<in>A. Sup ((f n) ` UNIV))"
 proof (cases "finite A")
   case True
   then show ?thesis using assms
     by induct (auto simp: incseq_sumI2 sum_nonneg SUP_ereal_add_pos)
 next
   case False
   then show ?thesis by simp
 qed
 
 lemma SUP_ereal_mult_left:
   fixes f :: "'a \<Rightarrow> ereal"
   assumes "I \<noteq> {}"
   assumes f: "\<And>i. i \<in> I \<Longrightarrow> 0 \<le> f i" and c: "0 \<le> c"
   shows "(SUP i\<in>I. c * f i) = c * (SUP i\<in>I. f i)"
 proof (cases "(SUP i \<in> I. f i) = 0")
   case True
   then have "\<And>i. i \<in> I \<Longrightarrow> f i = 0"
     by (metis SUP_upper f antisym)
   with True show ?thesis
     by simp
 next
   case False
   then show ?thesis
     by (subst continuous_at_Sup_mono[where f="\<lambda>x. c * x"])
        (auto simp: mono_def continuous_at continuous_at_imp_continuous_at_within \<open>I \<noteq> {}\<close> image_comp
              intro!: ereal_mult_left_mono c)
 qed
 
 lemma countable_approach:
   fixes x :: ereal
   assumes "x \<noteq> -\<infinity>"
   shows "\<exists>f. incseq f \<and> (\<forall>i::nat. f i < x) \<and> (f \<longlonglongrightarrow> x)"
 proof (cases x)
   case (real r)
   moreover have "(\<lambda>n. r - inverse (real (Suc n))) \<longlonglongrightarrow> r - 0"
     by (intro tendsto_intros LIMSEQ_inverse_real_of_nat)
   ultimately show ?thesis
     by (intro exI[of _ "\<lambda>n. x - inverse (Suc n)"]) (auto simp: incseq_def)
 next
   case PInf with LIMSEQ_SUP[of "\<lambda>n::nat. ereal (real n)"] show ?thesis
     by (intro exI[of _ "\<lambda>n. ereal (real n)"]) (auto simp: incseq_def SUP_nat_Infty)
 qed (simp add: assms)
 
 lemma Sup_countable_SUP:
   assumes "A \<noteq> {}"
   shows "\<exists>f::nat \<Rightarrow> ereal. incseq f \<and> range f \<subseteq> A \<and> Sup A = (SUP i. f i)"
 proof cases
   assume "Sup A = -\<infinity>"
   with \<open>A \<noteq> {}\<close> have "A = {-\<infinity>}"
     by (auto simp: Sup_eq_MInfty)
   then show ?thesis
     by (auto intro!: exI[of _ "\<lambda>_. -\<infinity>"] simp: bot_ereal_def)
 next
   assume "Sup A \<noteq> -\<infinity>"
   then obtain l where "incseq l" and l: "l i < Sup A" and l_Sup: "l \<longlonglongrightarrow> Sup A" for i :: nat
     by (auto dest: countable_approach)
 
-  have "\<exists>f. \<forall>n. (f n \<in> A \<and> l n \<le> f n) \<and> (f n \<le> f (Suc n))"
+  have "\<exists>f. \<forall>n. (f n \<in> A \<and> l n \<le> f n) \<and> (f n \<le> f (Suc n))" (is "\<exists>f. ?P f")
   proof (rule dependent_nat_choice)
     show "\<exists>x. x \<in> A \<and> l 0 \<le> x"
       using l[of 0] by (auto simp: less_Sup_iff)
   next
     fix x n assume "x \<in> A \<and> l n \<le> x"
     moreover from l[of "Suc n"] obtain y where "y \<in> A" "l (Suc n) < y"
       by (auto simp: less_Sup_iff)
     ultimately show "\<exists>y. (y \<in> A \<and> l (Suc n) \<le> y) \<and> x \<le> y"
       by (auto intro!: exI[of _ "max x y"] split: split_max)
   qed
-  then guess f .. note f = this
+  then obtain f where f: "?P f" ..
   then have "range f \<subseteq> A" "incseq f"
     by (auto simp: incseq_Suc_iff)
   moreover
   have "(SUP i. f i) = Sup A"
   proof (rule tendsto_unique)
     show "f \<longlonglongrightarrow> (SUP i. f i)"
       by (rule LIMSEQ_SUP \<open>incseq f\<close>)+
     show "f \<longlonglongrightarrow> Sup A"
       using l f
       by (intro tendsto_sandwich[OF _ _ l_Sup tendsto_const])
          (auto simp: Sup_upper)
   qed simp
   ultimately show ?thesis
     by auto
 qed
 
 lemma Inf_countable_INF:
   assumes "A \<noteq> {}" shows "\<exists>f::nat \<Rightarrow> ereal. decseq f \<and> range f \<subseteq> A \<and> Inf A = (INF i. f i)"
 proof -
   obtain f where "incseq f" "range f \<subseteq> uminus`A" "Sup (uminus`A) = (SUP i. f i)"
     using Sup_countable_SUP[of "uminus ` A"] \<open>A \<noteq> {}\<close> by auto
   then show ?thesis
     by (intro exI[of _ "\<lambda>x. - f x"])
        (auto simp: ereal_Sup_uminus_image_eq ereal_INF_uminus_eq eq_commute[of "- _"])
 qed
 
 lemma SUP_countable_SUP:
   "A \<noteq> {} \<Longrightarrow> \<exists>f::nat \<Rightarrow> ereal. range f \<subseteq> g`A \<and> Sup (g ` A) = Sup (f ` UNIV)"
   using Sup_countable_SUP [of "g`A"] by auto
 
 subsection "Relation to \<^typ>\<open>enat\<close>"
 
 definition "ereal_of_enat n = (case n of enat n \<Rightarrow> ereal (real n) | \<infinity> \<Rightarrow> \<infinity>)"
 
 declare [[coercion "ereal_of_enat :: enat \<Rightarrow> ereal"]]
 declare [[coercion "(\<lambda>n. ereal (real n)) :: nat \<Rightarrow> ereal"]]
 
 lemma ereal_of_enat_simps[simp]:
   "ereal_of_enat (enat n) = ereal n"
   "ereal_of_enat \<infinity> = \<infinity>"
   by (simp_all add: ereal_of_enat_def)
 
 lemma ereal_of_enat_le_iff[simp]: "ereal_of_enat m \<le> ereal_of_enat n \<longleftrightarrow> m \<le> n"
   by (cases m n rule: enat2_cases) auto
 
 lemma ereal_of_enat_less_iff[simp]: "ereal_of_enat m < ereal_of_enat n \<longleftrightarrow> m < n"
   by (cases m n rule: enat2_cases) auto
 
 lemma numeral_le_ereal_of_enat_iff[simp]: "numeral m \<le> ereal_of_enat n \<longleftrightarrow> numeral m \<le> n"
 by (cases n) (auto)
 
 lemma numeral_less_ereal_of_enat_iff[simp]: "numeral m < ereal_of_enat n \<longleftrightarrow> numeral m < n"
   by (cases n) auto
 
 lemma ereal_of_enat_ge_zero_cancel_iff[simp]: "0 \<le> ereal_of_enat n \<longleftrightarrow> 0 \<le> n"
   by (cases n) (auto simp flip: enat_0)
 
 lemma ereal_of_enat_gt_zero_cancel_iff[simp]: "0 < ereal_of_enat n \<longleftrightarrow> 0 < n"
   by (cases n) (auto simp flip: enat_0)
 
 lemma ereal_of_enat_zero[simp]: "ereal_of_enat 0 = 0"
   by (auto simp flip: enat_0)
 
 lemma ereal_of_enat_inf[simp]: "ereal_of_enat n = \<infinity> \<longleftrightarrow> n = \<infinity>"
   by (cases n) auto
 
 lemma ereal_of_enat_add: "ereal_of_enat (m + n) = ereal_of_enat m + ereal_of_enat n"
   by (cases m n rule: enat2_cases) auto
 
 lemma ereal_of_enat_sub:
   assumes "n \<le> m"
   shows "ereal_of_enat (m - n) = ereal_of_enat m - ereal_of_enat n "
   using assms by (cases m n rule: enat2_cases) auto
 
 lemma ereal_of_enat_mult:
   "ereal_of_enat (m * n) = ereal_of_enat m * ereal_of_enat n"
   by (cases m n rule: enat2_cases) auto
 
 lemmas ereal_of_enat_pushin = ereal_of_enat_add ereal_of_enat_sub ereal_of_enat_mult
 lemmas ereal_of_enat_pushout = ereal_of_enat_pushin[symmetric]
 
 lemma ereal_of_enat_nonneg: "ereal_of_enat n \<ge> 0"
 by(cases n) simp_all
 
 lemma ereal_of_enat_Sup:
   assumes "A \<noteq> {}" shows "ereal_of_enat (Sup A) = (SUP a \<in> A. ereal_of_enat a)"
 proof (intro antisym mono_Sup)
   show "ereal_of_enat (Sup A) \<le> (SUP a \<in> A. ereal_of_enat a)"
   proof cases
     assume "finite A"
     with \<open>A \<noteq> {}\<close> obtain a where "a \<in> A" "ereal_of_enat (Sup A) = ereal_of_enat a"
       using Max_in[of A] by (auto simp: Sup_enat_def simp del: Max_in)
     then show ?thesis
       by (auto intro: SUP_upper)
   next
     assume "\<not> finite A"
     have [simp]: "(SUP a \<in> A. ereal_of_enat a) = top"
       unfolding SUP_eq_top_iff
     proof safe
       fix x :: ereal assume "x < top"
       then obtain n :: nat where "x < n"
         using less_PInf_Ex_of_nat top_ereal_def by auto
       obtain a where "a \<in> A - enat ` {.. n}"
         by (metis \<open>\<not> finite A\<close> all_not_in_conv finite_Diff2 finite_atMost finite_imageI finite.emptyI)
       then have "a \<in> A" "ereal n \<le> ereal_of_enat a"
         by (auto simp: image_iff Ball_def)
            (metis enat_iless enat_ord_simps(1) ereal_of_enat_less_iff ereal_of_enat_simps(1) less_le not_less)
       with \<open>x < n\<close> show "\<exists>i\<in>A. x < ereal_of_enat i"
         by (auto intro!: bexI[of _ a])
     qed
     show ?thesis
       by simp
   qed
 qed (simp add: mono_def)
 
 lemma ereal_of_enat_SUP:
   "A \<noteq> {} \<Longrightarrow> ereal_of_enat (SUP a\<in>A. f a) = (SUP a \<in> A. ereal_of_enat (f a))"
   by (simp add: ereal_of_enat_Sup image_comp)
 
 
 subsection "Limits on \<^typ>\<open>ereal\<close>"
 
 lemma open_PInfty: "open A \<Longrightarrow> \<infinity> \<in> A \<Longrightarrow> (\<exists>x. {ereal x<..} \<subseteq> A)"
   unfolding open_ereal_generated
 proof (induct rule: generate_topology.induct)
   case (Int A B)
   then obtain x z where "\<infinity> \<in> A \<Longrightarrow> {ereal x <..} \<subseteq> A" "\<infinity> \<in> B \<Longrightarrow> {ereal z <..} \<subseteq> B"
     by auto
   with Int show ?case
     by (intro exI[of _ "max x z"]) fastforce
 next
   case (Basis S)
   {
     fix x
     have "x \<noteq> \<infinity> \<Longrightarrow> \<exists>t. x \<le> ereal t"
       by (cases x) auto
   }
   moreover note Basis
   ultimately show ?case
     by (auto split: ereal.split)
 qed (fastforce simp add: vimage_Union)+
 
 lemma open_MInfty: "open A \<Longrightarrow> -\<infinity> \<in> A \<Longrightarrow> (\<exists>x. {..<ereal x} \<subseteq> A)"
   unfolding open_ereal_generated
 proof (induct rule: generate_topology.induct)
   case (Int A B)
   then obtain x z where "-\<infinity> \<in> A \<Longrightarrow> {..< ereal x} \<subseteq> A" "-\<infinity> \<in> B \<Longrightarrow> {..< ereal z} \<subseteq> B"
     by auto
   with Int show ?case
     by (intro exI[of _ "min x z"]) fastforce
 next
   case (Basis S)
   {
     fix x
     have "x \<noteq> - \<infinity> \<Longrightarrow> \<exists>t. ereal t \<le> x"
       by (cases x) auto
   }
   moreover note Basis
   ultimately show ?case
     by (auto split: ereal.split)
 qed (fastforce simp add: vimage_Union)+
 
 lemma open_ereal_vimage: "open S \<Longrightarrow> open (ereal -` S)"
   by (intro open_vimage continuous_intros)
 
 lemma open_ereal: "open S \<Longrightarrow> open (ereal ` S)"
   unfolding open_generated_order[where 'a=real]
 proof (induct rule: generate_topology.induct)
   case (Basis S)
   moreover have "\<And>x. ereal ` {..< x} = { -\<infinity> <..< ereal x }"
     using ereal_less_ereal_Ex by auto
   moreover have "\<And>x. ereal ` {x <..} = { ereal x <..< \<infinity> }"
     using less_ereal.elims(2) by fastforce
   ultimately show ?case
     by auto
 qed (auto simp add: image_Union image_Int)
 
 lemma open_image_real_of_ereal:
   fixes X::"ereal set"
   assumes "open X"
   assumes infty: "\<infinity> \<notin> X" "-\<infinity> \<notin> X"
   shows "open (real_of_ereal ` X)"
 proof -
   have "real_of_ereal ` X = ereal -` X"
     using infty ereal_real by (force simp: set_eq_iff)
   thus ?thesis
     by (auto intro!: open_ereal_vimage assms)
 qed
 
 lemma eventually_finite:
   fixes x :: ereal
   assumes "\<bar>x\<bar> \<noteq> \<infinity>" "(f \<longlongrightarrow> x) F"
   shows "eventually (\<lambda>x. \<bar>f x\<bar> \<noteq> \<infinity>) F"
 proof -
   have "(f \<longlongrightarrow> ereal (real_of_ereal x)) F"
     using assms by (cases x) auto
   then have "eventually (\<lambda>x. f x \<in> ereal ` UNIV) F"
     by (rule topological_tendstoD) (auto intro: open_ereal)
   also have "(\<lambda>x. f x \<in> ereal ` UNIV) = (\<lambda>x. \<bar>f x\<bar> \<noteq> \<infinity>)"
     by auto
   finally show ?thesis .
 qed
 
 
 lemma open_ereal_def:
   "open A \<longleftrightarrow> open (ereal -` A) \<and> (\<infinity> \<in> A \<longrightarrow> (\<exists>x. {ereal x <..} \<subseteq> A)) \<and> (-\<infinity> \<in> A \<longrightarrow> (\<exists>x. {..<ereal x} \<subseteq> A))"
   (is "open A \<longleftrightarrow> ?rhs")
 proof
   assume "open A"
   then show ?rhs
     using open_PInfty open_MInfty open_ereal_vimage by auto
 next
   assume "?rhs"
   then obtain x y where A: "open (ereal -` A)" "\<infinity> \<in> A \<Longrightarrow> {ereal x<..} \<subseteq> A" "-\<infinity> \<in> A \<Longrightarrow> {..< ereal y} \<subseteq> A"
     by auto
   have *: "A = ereal ` (ereal -` A) \<union> (if \<infinity> \<in> A then {ereal x<..} else {}) \<union> (if -\<infinity> \<in> A then {..< ereal y} else {})"
     using A(2,3) by auto
   from open_ereal[OF A(1)] show "open A"
     by (subst *) (auto simp: open_Un)
 qed
 
 lemma open_PInfty2:
   assumes "open A"
     and "\<infinity> \<in> A"
   obtains x where "{ereal x<..} \<subseteq> A"
   using open_PInfty[OF assms] by auto
 
 lemma open_MInfty2:
   assumes "open A"
     and "-\<infinity> \<in> A"
   obtains x where "{..<ereal x} \<subseteq> A"
   using open_MInfty[OF assms] by auto
 
 lemma ereal_openE:
   assumes "open A"
   obtains x y where "open (ereal -` A)"
     and "\<infinity> \<in> A \<Longrightarrow> {ereal x<..} \<subseteq> A"
     and "-\<infinity> \<in> A \<Longrightarrow> {..<ereal y} \<subseteq> A"
   using assms open_ereal_def by auto
 
 lemmas open_ereal_lessThan = open_lessThan[where 'a=ereal]
 lemmas open_ereal_greaterThan = open_greaterThan[where 'a=ereal]
 lemmas ereal_open_greaterThanLessThan = open_greaterThanLessThan[where 'a=ereal]
 lemmas closed_ereal_atLeast = closed_atLeast[where 'a=ereal]
 lemmas closed_ereal_atMost = closed_atMost[where 'a=ereal]
 lemmas closed_ereal_atLeastAtMost = closed_atLeastAtMost[where 'a=ereal]
 lemmas closed_ereal_singleton = closed_singleton[where 'a=ereal]
 
 lemma ereal_open_cont_interval:
   fixes S :: "ereal set"
   assumes "open S"
     and "x \<in> S"
     and "\<bar>x\<bar> \<noteq> \<infinity>"
   obtains e where "e > 0" and "{x-e <..< x+e} \<subseteq> S"
 proof -
   from \<open>open S\<close>
   have "open (ereal -` S)"
     by (rule ereal_openE)
   then obtain e where "e > 0" and e: "dist y (real_of_ereal x) < e \<Longrightarrow> ereal y \<in> S" for y
     using assms unfolding open_dist by force
   show thesis
   proof (intro that subsetI)
     show "0 < ereal e"
       using \<open>0 < e\<close> by auto
     fix y
     assume "y \<in> {x - ereal e<..<x + ereal e}"
     with assms obtain t where "y = ereal t" "dist t (real_of_ereal x) < e"
       by (cases y) (auto simp: dist_real_def)
     then show "y \<in> S"
       using e[of t] by auto
   qed
 qed
 
 lemma ereal_open_cont_interval2:
   fixes S :: "ereal set"
   assumes "open S"
     and "x \<in> S"
     and x: "\<bar>x\<bar> \<noteq> \<infinity>"
   obtains a b where "a < x" and "x < b" and "{a <..< b} \<subseteq> S"
 proof -
   obtain e where "0 < e" "{x - e<..<x + e} \<subseteq> S"
     using assms by (rule ereal_open_cont_interval)
   with that[of "x - e" "x + e"] ereal_between[OF x, of e]
   show thesis
     by auto
 qed
 
 subsubsection \<open>Convergent sequences\<close>
 
 lemma lim_real_of_ereal[simp]:
   assumes lim: "(f \<longlongrightarrow> ereal x) net"
   shows "((\<lambda>x. real_of_ereal (f x)) \<longlongrightarrow> x) net"
 proof (intro topological_tendstoI)
   fix S
   assume "open S" and "x \<in> S"
   then have S: "open S" "ereal x \<in> ereal ` S"
     by (simp_all add: inj_image_mem_iff)
   show "eventually (\<lambda>x. real_of_ereal (f x) \<in> S) net"
     by (auto intro: eventually_mono [OF lim[THEN topological_tendstoD, OF open_ereal, OF S]])
 qed
 
 lemma lim_ereal[simp]: "((\<lambda>n. ereal (f n)) \<longlongrightarrow> ereal x) net \<longleftrightarrow> (f \<longlongrightarrow> x) net"
   by (auto dest!: lim_real_of_ereal)
 
 lemma convergent_real_imp_convergent_ereal:
   assumes "convergent a"
   shows "convergent (\<lambda>n. ereal (a n))" and "lim (\<lambda>n. ereal (a n)) = ereal (lim a)"
 proof -
   from assms obtain L where L: "a \<longlonglongrightarrow> L" unfolding convergent_def ..
   hence lim: "(\<lambda>n. ereal (a n)) \<longlonglongrightarrow> ereal L" using lim_ereal by auto
   thus "convergent (\<lambda>n. ereal (a n))" unfolding convergent_def ..
   thus "lim (\<lambda>n. ereal (a n)) = ereal (lim a)" using lim L limI by metis
 qed
 
 lemma tendsto_PInfty: "(f \<longlongrightarrow> \<infinity>) F \<longleftrightarrow> (\<forall>r. eventually (\<lambda>x. ereal r < f x) F)"
 proof -
   {
     fix l :: ereal
     assume "\<forall>r. eventually (\<lambda>x. ereal r < f x) F"
     from this[THEN spec, of "real_of_ereal l"] have "l \<noteq> \<infinity> \<Longrightarrow> eventually (\<lambda>x. l < f x) F"
       by (cases l) (auto elim: eventually_mono)
   }
   then show ?thesis
     by (auto simp: order_tendsto_iff)
 qed
 
 lemma tendsto_PInfty': "(f \<longlongrightarrow> \<infinity>) F = (\<forall>r>c. eventually (\<lambda>x. ereal r < f x) F)"
 proof (subst tendsto_PInfty, intro iffI allI impI)
   assume A: "\<forall>r>c. eventually (\<lambda>x. ereal r < f x) F"
   fix r :: real
   from A have A: "eventually (\<lambda>x. ereal r < f x) F" if "r > c" for r using that by blast
   show "eventually (\<lambda>x. ereal r < f x) F"
   proof (cases "r > c")
     case False
     hence B: "ereal r \<le> ereal (c + 1)" by simp
     have "c < c + 1" by simp
     from A[OF this] show "eventually (\<lambda>x. ereal r < f x) F"
       by eventually_elim (rule le_less_trans[OF B])
   qed (simp add: A)
 qed simp
 
 lemma tendsto_PInfty_eq_at_top:
   "((\<lambda>z. ereal (f z)) \<longlongrightarrow> \<infinity>) F \<longleftrightarrow> (LIM z F. f z :> at_top)"
   unfolding tendsto_PInfty filterlim_at_top_dense by simp
 
 lemma tendsto_MInfty: "(f \<longlongrightarrow> -\<infinity>) F \<longleftrightarrow> (\<forall>r. eventually (\<lambda>x. f x < ereal r) F)"
   unfolding tendsto_def
 proof safe
   fix S :: "ereal set"
   assume "open S" "-\<infinity> \<in> S"
   from open_MInfty[OF this] obtain B where "{..<ereal B} \<subseteq> S" ..
   moreover
   assume "\<forall>r::real. eventually (\<lambda>z. f z < r) F"
   then have "eventually (\<lambda>z. f z \<in> {..< B}) F"
     by auto
   ultimately show "eventually (\<lambda>z. f z \<in> S) F"
     by (auto elim!: eventually_mono)
 next
   fix x
   assume "\<forall>S. open S \<longrightarrow> -\<infinity> \<in> S \<longrightarrow> eventually (\<lambda>x. f x \<in> S) F"
   from this[rule_format, of "{..< ereal x}"] show "eventually (\<lambda>y. f y < ereal x) F"
     by auto
 qed
 
 lemma tendsto_MInfty': "(f \<longlongrightarrow> -\<infinity>) F = (\<forall>r<c. eventually (\<lambda>x. ereal r > f x) F)"
 proof (subst tendsto_MInfty, intro iffI allI impI)
   assume A: "\<forall>r<c. eventually (\<lambda>x. ereal r > f x) F"
   fix r :: real
   from A have A: "eventually (\<lambda>x. ereal r > f x) F" if "r < c" for r using that by blast
   show "eventually (\<lambda>x. ereal r > f x) F"
   proof (cases "r < c")
     case False
     hence B: "ereal r \<ge> ereal (c - 1)" by simp
     have "c > c - 1" by simp
     from A[OF this] show "eventually (\<lambda>x. ereal r > f x) F"
       by eventually_elim (erule less_le_trans[OF _ B])
   qed (simp add: A)
 qed simp
 
 lemma Lim_PInfty: "f \<longlonglongrightarrow> \<infinity> \<longleftrightarrow> (\<forall>B. \<exists>N. \<forall>n\<ge>N. f n \<ge> ereal B)"
   unfolding tendsto_PInfty eventually_sequentially
 proof safe
   fix r
   assume "\<forall>r. \<exists>N. \<forall>n\<ge>N. ereal r \<le> f n"
   then obtain N where "\<forall>n\<ge>N. ereal (r + 1) \<le> f n"
     by blast
   moreover have "ereal r < ereal (r + 1)"
     by auto
   ultimately show "\<exists>N. \<forall>n\<ge>N. ereal r < f n"
     by (blast intro: less_le_trans)
 qed (blast intro: less_imp_le)
 
 lemma Lim_MInfty: "f \<longlonglongrightarrow> -\<infinity> \<longleftrightarrow> (\<forall>B. \<exists>N. \<forall>n\<ge>N. ereal B \<ge> f n)"
   unfolding tendsto_MInfty eventually_sequentially
 proof safe
   fix r
   assume "\<forall>r. \<exists>N. \<forall>n\<ge>N. f n \<le> ereal r"
   then obtain N where "\<forall>n\<ge>N. f n \<le> ereal (r - 1)"
     by blast
   moreover have "ereal (r - 1) < ereal r"
     by auto
   ultimately show "\<exists>N. \<forall>n\<ge>N. f n < ereal r"
     by (blast intro: le_less_trans)
 qed (blast intro: less_imp_le)
 
 lemma Lim_bounded_PInfty: "f \<longlonglongrightarrow> l \<Longrightarrow> (\<And>n. f n \<le> ereal B) \<Longrightarrow> l \<noteq> \<infinity>"
   using LIMSEQ_le_const2[of f l "ereal B"] by auto
 
 lemma Lim_bounded_MInfty: "f \<longlonglongrightarrow> l \<Longrightarrow> (\<And>n. ereal B \<le> f n) \<Longrightarrow> l \<noteq> -\<infinity>"
   using LIMSEQ_le_const[of f l "ereal B"] by auto
 
 lemma tendsto_zero_erealI:
   assumes "\<And>e. e > 0 \<Longrightarrow> eventually (\<lambda>x. \<bar>f x\<bar> < ereal e) F"
   shows   "(f \<longlongrightarrow> 0) F"
 proof (subst filterlim_cong[OF refl refl])
   from assms[OF zero_less_one] show "eventually (\<lambda>x. f x = ereal (real_of_ereal (f x))) F"
     by eventually_elim (auto simp: ereal_real)
   hence "eventually (\<lambda>x. abs (real_of_ereal (f x)) < e) F" if "e > 0" for e using assms[OF that]
     by eventually_elim (simp add: real_less_ereal_iff that)
   hence "((\<lambda>x. real_of_ereal (f x)) \<longlongrightarrow> 0) F" unfolding tendsto_iff
     by (auto simp: tendsto_iff dist_real_def)
   thus "((\<lambda>x. ereal (real_of_ereal (f x))) \<longlongrightarrow> 0) F" by (simp add: zero_ereal_def)
 qed
 
 lemma Lim_bounded_PInfty2: "f \<longlonglongrightarrow> l \<Longrightarrow> \<forall>n\<ge>N. f n \<le> ereal B \<Longrightarrow> l \<noteq> \<infinity>"
   using LIMSEQ_le_const2[of f l "ereal B"] by fastforce
 
 lemma real_of_ereal_mult[simp]:
   fixes a b :: ereal
   shows "real_of_ereal (a * b) = real_of_ereal a * real_of_ereal b"
   by (cases rule: ereal2_cases[of a b]) auto
 
 lemma real_of_ereal_eq_0:
   fixes x :: ereal
   shows "real_of_ereal x = 0 \<longleftrightarrow> x = \<infinity> \<or> x = -\<infinity> \<or> x = 0"
   by (cases x) auto
 
 lemma tendsto_ereal_realD:
   fixes f :: "'a \<Rightarrow> ereal"
   assumes "x \<noteq> 0"
     and tendsto: "((\<lambda>x. ereal (real_of_ereal (f x))) \<longlongrightarrow> x) net"
   shows "(f \<longlongrightarrow> x) net"
 proof (intro topological_tendstoI)
   fix S
   assume S: "open S" "x \<in> S"
   with \<open>x \<noteq> 0\<close> have "open (S - {0})" "x \<in> S - {0}"
     by auto
   from tendsto[THEN topological_tendstoD, OF this]
   show "eventually (\<lambda>x. f x \<in> S) net"
     by (rule eventually_rev_mp) (auto simp: ereal_real)
 qed
 
 lemma tendsto_ereal_realI:
   fixes f :: "'a \<Rightarrow> ereal"
   assumes x: "\<bar>x\<bar> \<noteq> \<infinity>" and tendsto: "(f \<longlongrightarrow> x) net"
   shows "((\<lambda>x. ereal (real_of_ereal (f x))) \<longlongrightarrow> x) net"
 proof (intro topological_tendstoI)
   fix S
   assume "open S" and "x \<in> S"
   with x have "open (S - {\<infinity>, -\<infinity>})" "x \<in> S - {\<infinity>, -\<infinity>}"
     by auto
   from tendsto[THEN topological_tendstoD, OF this]
   show "eventually (\<lambda>x. ereal (real_of_ereal (f x)) \<in> S) net"
     by (elim eventually_mono) (auto simp: ereal_real)
 qed
 
 lemma ereal_mult_cancel_left:
   fixes a b c :: ereal
   shows "a * b = a * c \<longleftrightarrow> (\<bar>a\<bar> = \<infinity> \<and> 0 < b * c) \<or> a = 0 \<or> b = c"
   by (cases rule: ereal3_cases[of a b c]) (simp_all add: zero_less_mult_iff)
 
 lemma tendsto_add_ereal:
   fixes x y :: ereal
   assumes x: "\<bar>x\<bar> \<noteq> \<infinity>" and y: "\<bar>y\<bar> \<noteq> \<infinity>"
   assumes f: "(f \<longlongrightarrow> x) F" and g: "(g \<longlongrightarrow> y) F"
   shows "((\<lambda>x. f x + g x) \<longlongrightarrow> x + y) F"
 proof -
   from x obtain r where x': "x = ereal r" by (cases x) auto
   with f have "((\<lambda>i. real_of_ereal (f i)) \<longlongrightarrow> r) F" by simp
   moreover
   from y obtain p where y': "y = ereal p" by (cases y) auto
   with g have "((\<lambda>i. real_of_ereal (g i)) \<longlongrightarrow> p) F" by simp
   ultimately have "((\<lambda>i. real_of_ereal (f i) + real_of_ereal (g i)) \<longlongrightarrow> r + p) F"
     by (rule tendsto_add)
   moreover
   from eventually_finite[OF x f] eventually_finite[OF y g]
   have "eventually (\<lambda>x. f x + g x = ereal (real_of_ereal (f x) + real_of_ereal (g x))) F"
     by eventually_elim auto
   ultimately show ?thesis
     by (simp add: x' y' cong: filterlim_cong)
 qed
 
 lemma tendsto_add_ereal_nonneg:
   fixes x y :: "ereal"
   assumes "x \<noteq> -\<infinity>" "y \<noteq> -\<infinity>" "(f \<longlongrightarrow> x) F" "(g \<longlongrightarrow> y) F"
   shows "((\<lambda>x. f x + g x) \<longlongrightarrow> x + y) F"
 proof cases
   assume "x = \<infinity> \<or> y = \<infinity>"
   moreover
   { fix y :: ereal and f g :: "'a \<Rightarrow> ereal" assume "y \<noteq> -\<infinity>" "(f \<longlongrightarrow> \<infinity>) F" "(g \<longlongrightarrow> y) F"
     then obtain y' where "-\<infinity> < y'" "y' < y"
       using dense[of "-\<infinity>" y] by auto
     have "((\<lambda>x. f x + g x) \<longlongrightarrow> \<infinity>) F"
     proof (rule tendsto_sandwich)
       have "\<forall>\<^sub>F x in F. y' < g x"
         using order_tendstoD(1)[OF \<open>(g \<longlongrightarrow> y) F\<close> \<open>y' < y\<close>] by auto
       then show "\<forall>\<^sub>F x in F. f x + y' \<le> f x + g x"
         by eventually_elim (auto intro!: add_mono)
       show "\<forall>\<^sub>F n in F. f n + g n \<le> \<infinity>" "((\<lambda>n. \<infinity>) \<longlongrightarrow> \<infinity>) F"
         by auto
       show "((\<lambda>x. f x + y') \<longlongrightarrow> \<infinity>) F"
         using tendsto_cadd_ereal[of y' \<infinity> f F] \<open>(f \<longlongrightarrow> \<infinity>) F\<close> \<open>-\<infinity> < y'\<close> by auto
     qed }
   note this[of y f g] this[of x g f]
   ultimately show ?thesis
     using assms by (auto simp: add_ac)
 next
   assume "\<not> (x = \<infinity> \<or> y = \<infinity>)"
   with assms tendsto_add_ereal[of x y f F g]
   show ?thesis
     by auto
 qed
 
 lemma ereal_inj_affinity:
   fixes m t :: ereal
   assumes "\<bar>m\<bar> \<noteq> \<infinity>"
     and "m \<noteq> 0"
     and "\<bar>t\<bar> \<noteq> \<infinity>"
   shows "inj_on (\<lambda>x. m * x + t) A"
   using assms
   by (cases rule: ereal2_cases[of m t])
      (auto intro!: inj_onI simp: ereal_add_cancel_right ereal_mult_cancel_left)
 
 lemma ereal_PInfty_eq_plus[simp]:
   fixes a b :: ereal
   shows "\<infinity> = a + b \<longleftrightarrow> a = \<infinity> \<or> b = \<infinity>"
   by (cases rule: ereal2_cases[of a b]) auto
 
 lemma ereal_MInfty_eq_plus[simp]:
   fixes a b :: ereal
   shows "-\<infinity> = a + b \<longleftrightarrow> (a = -\<infinity> \<and> b \<noteq> \<infinity>) \<or> (b = -\<infinity> \<and> a \<noteq> \<infinity>)"
   by (cases rule: ereal2_cases[of a b]) auto
 
 lemma ereal_less_divide_pos:
   fixes x y :: ereal
   shows "x > 0 \<Longrightarrow> x \<noteq> \<infinity> \<Longrightarrow> y < z / x \<longleftrightarrow> x * y < z"
   by (cases rule: ereal3_cases[of x y z]) (auto simp: field_simps)
 
 lemma ereal_divide_less_pos:
   fixes x y z :: ereal
   shows "x > 0 \<Longrightarrow> x \<noteq> \<infinity> \<Longrightarrow> y / x < z \<longleftrightarrow> y < x * z"
   by (cases rule: ereal3_cases[of x y z]) (auto simp: field_simps)
 
 lemma ereal_divide_eq:
   fixes a b c :: ereal
   shows "b \<noteq> 0 \<Longrightarrow> \<bar>b\<bar> \<noteq> \<infinity> \<Longrightarrow> a / b = c \<longleftrightarrow> a = b * c"
   by (cases rule: ereal3_cases[of a b c])
      (simp_all add: field_simps)
 
 lemma ereal_inverse_not_MInfty[simp]: "inverse (a::ereal) \<noteq> -\<infinity>"
   by (cases a) auto
 
 lemma ereal_mult_m1[simp]: "x * ereal (-1) = -x"
   by (cases x) auto
 
 lemma ereal_real':
   assumes "\<bar>x\<bar> \<noteq> \<infinity>"
   shows "ereal (real_of_ereal x) = x"
   using assms by auto
 
 lemma real_ereal_id: "real_of_ereal \<circ> ereal = id"
 proof -
   {
     fix x
     have "(real_of_ereal \<circ> ereal) x = id x"
       by auto
   }
   then show ?thesis
     using ext by blast
 qed
 
 lemma open_image_ereal: "open(UNIV-{ \<infinity> , (-\<infinity> :: ereal)})"
   by (metis range_ereal open_ereal open_UNIV)
 
 lemma ereal_le_distrib:
   fixes a b c :: ereal
   shows "c * (a + b) \<le> c * a + c * b"
   by (cases rule: ereal3_cases[of a b c])
      (auto simp add: field_simps not_le mult_le_0_iff mult_less_0_iff)
 
 lemma ereal_pos_distrib:
   fixes a b c :: ereal
   assumes "0 \<le> c"
     and "c \<noteq> \<infinity>"
   shows "c * (a + b) = c * a + c * b"
   using assms
   by (cases rule: ereal3_cases[of a b c])
     (auto simp add: field_simps not_le mult_le_0_iff mult_less_0_iff)
 
 lemma ereal_LimI_finite:
   fixes x :: ereal
   assumes "\<bar>x\<bar> \<noteq> \<infinity>"
     and "\<And>r. 0 < r \<Longrightarrow> \<exists>N. \<forall>n\<ge>N. u n < x + r \<and> x < u n + r"
   shows "u \<longlonglongrightarrow> x"
 proof (rule topological_tendstoI, unfold eventually_sequentially)
   obtain rx where rx: "x = ereal rx"
     using assms by (cases x) auto
   fix S
   assume "open S" and "x \<in> S"
   then have "open (ereal -` S)"
     unfolding open_ereal_def by auto
   with \<open>x \<in> S\<close> obtain r where "0 < r" and dist: "dist y rx < r \<Longrightarrow> ereal y \<in> S" for y
     unfolding open_dist rx by auto
   then obtain n
     where upper: "u N < x + ereal r"
       and lower: "x < u N + ereal r"
       if "n \<le> N" for N
     using assms(2)[of "ereal r"] by auto
   show "\<exists>N. \<forall>n\<ge>N. u n \<in> S"
   proof (safe intro!: exI[of _ n])
     fix N
     assume "n \<le> N"
     from upper[OF this] lower[OF this] assms \<open>0 < r\<close>
     have "u N \<notin> {\<infinity>,(-\<infinity>)}"
       by auto
     then obtain ra where ra_def: "(u N) = ereal ra"
       by (cases "u N") auto
     then have "rx < ra + r" and "ra < rx + r"
       using rx assms \<open>0 < r\<close> lower[OF \<open>n \<le> N\<close>] upper[OF \<open>n \<le> N\<close>]
       by auto
     then have "dist (real_of_ereal (u N)) rx < r"
       using rx ra_def
       by (auto simp: dist_real_def abs_diff_less_iff field_simps)
     from dist[OF this] show "u N \<in> S"
       using \<open>u N  \<notin> {\<infinity>, -\<infinity>}\<close>
       by (auto simp: ereal_real split: if_split_asm)
   qed
 qed
 
 lemma tendsto_obtains_N:
   assumes "f \<longlonglongrightarrow> f0"
   assumes "open S"
     and "f0 \<in> S"
   obtains N where "\<forall>n\<ge>N. f n \<in> S"
   using assms using tendsto_def
   using lim_explicit[of f f0] assms by auto
 
 lemma ereal_LimI_finite_iff:
   fixes x :: ereal
   assumes "\<bar>x\<bar> \<noteq> \<infinity>"
   shows "u \<longlonglongrightarrow> x \<longleftrightarrow> (\<forall>r. 0 < r \<longrightarrow> (\<exists>N. \<forall>n\<ge>N. u n < x + r \<and> x < u n + r))"
   (is "?lhs \<longleftrightarrow> ?rhs")
 proof
   assume lim: "u \<longlonglongrightarrow> x"
   {
     fix r :: ereal
     assume "r > 0"
     then obtain N where "\<forall>n\<ge>N. u n \<in> {x - r <..< x + r}"
        apply (subst tendsto_obtains_N[of u x "{x - r <..< x + r}"])
        using lim ereal_between[of x r] assms \<open>r > 0\<close>
        apply auto
        done
     then have "\<exists>N. \<forall>n\<ge>N. u n < x + r \<and> x < u n + r"
       using ereal_minus_less[of r x]
       by (cases r) auto
   }
   then show ?rhs
     by auto
 next
   assume ?rhs
   then show "u \<longlonglongrightarrow> x"
     using ereal_LimI_finite[of x] assms by auto
 qed
 
 lemma ereal_Limsup_uminus:
   fixes f :: "'a \<Rightarrow> ereal"
   shows "Limsup net (\<lambda>x. - (f x)) = - Liminf net f"
   unfolding Limsup_def Liminf_def ereal_SUP_uminus ereal_INF_uminus_eq ..
 
 lemma liminf_bounded_iff:
   fixes x :: "nat \<Rightarrow> ereal"
   shows "C \<le> liminf x \<longleftrightarrow> (\<forall>B<C. \<exists>N. \<forall>n\<ge>N. B < x n)"
   (is "?lhs \<longleftrightarrow> ?rhs")
   unfolding le_Liminf_iff eventually_sequentially ..
 
 lemma Liminf_add_le:
   fixes f g :: "_ \<Rightarrow> ereal"
   assumes F: "F \<noteq> bot"
   assumes ev: "eventually (\<lambda>x. 0 \<le> f x) F" "eventually (\<lambda>x. 0 \<le> g x) F"
   shows "Liminf F f + Liminf F g \<le> Liminf F (\<lambda>x. f x + g x)"
   unfolding Liminf_def
 proof (subst SUP_ereal_add_left[symmetric])
   let ?F = "{P. eventually P F}"
   let ?INF = "\<lambda>P g. Inf (g ` (Collect P))"
   show "?F \<noteq> {}"
     by (auto intro: eventually_True)
   show "(SUP P\<in>?F. ?INF P g) \<noteq> - \<infinity>"
     unfolding bot_ereal_def[symmetric] SUP_bot_conv INF_eq_bot_iff
     by (auto intro!: exI[of _ 0] ev simp: bot_ereal_def)
   have "(SUP P\<in>?F. ?INF P f + (SUP P\<in>?F. ?INF P g)) \<le> (SUP P\<in>?F. (SUP P'\<in>?F. ?INF P f + ?INF P' g))"
   proof (safe intro!: SUP_mono bexI[of _ "\<lambda>x. P x \<and> 0 \<le> f x" for P])
     fix P let ?P' = "\<lambda>x. P x \<and> 0 \<le> f x"
     assume "eventually P F"
     with ev show "eventually ?P' F"
       by eventually_elim auto
     have "?INF P f + (SUP P\<in>?F. ?INF P g) \<le> ?INF ?P' f + (SUP P\<in>?F. ?INF P g)"
       by (intro add_mono INF_mono) auto
     also have "\<dots> = (SUP P'\<in>?F. ?INF ?P' f + ?INF P' g)"
     proof (rule SUP_ereal_add_right[symmetric])
       show "Inf (f ` {x. P x \<and> 0 \<le> f x}) \<noteq> - \<infinity>"
         unfolding bot_ereal_def[symmetric] INF_eq_bot_iff
         by (auto intro!: exI[of _ 0] ev simp: bot_ereal_def)
     qed fact
     finally show "?INF P f + (SUP P\<in>?F. ?INF P g) \<le> (SUP P'\<in>?F. ?INF ?P' f + ?INF P' g)" .
   qed
   also have "\<dots> \<le> (SUP P\<in>?F. INF x\<in>Collect P. f x + g x)"
   proof (safe intro!: SUP_least)
     fix P Q assume *: "eventually P F" "eventually Q F"
     show "?INF P f + ?INF Q g \<le> (SUP P\<in>?F. INF x\<in>Collect P. f x + g x)"
     proof (rule SUP_upper2)
       show "(\<lambda>x. P x \<and> Q x) \<in> ?F"
         using * by (auto simp: eventually_conj)
       show "?INF P f + ?INF Q g \<le> (INF x\<in>{x. P x \<and> Q x}. f x + g x)"
         by (intro INF_greatest add_mono) (auto intro: INF_lower)
     qed
   qed
   finally show "(SUP P\<in>?F. ?INF P f + (SUP P\<in>?F. ?INF P g)) \<le> (SUP P\<in>?F. INF x\<in>Collect P. f x + g x)" .
 qed
 
 lemma Sup_ereal_mult_right':
   assumes nonempty: "Y \<noteq> {}"
   and x: "x \<ge> 0"
   shows "(SUP i\<in>Y. f i) * ereal x = (SUP i\<in>Y. f i * ereal x)" (is "?lhs = ?rhs")
 proof(cases "x = 0")
   case True thus ?thesis by(auto simp add: nonempty zero_ereal_def[symmetric])
 next
   case False
   show ?thesis
   proof(rule antisym)
     show "?rhs \<le> ?lhs"
       by(rule SUP_least)(simp add: ereal_mult_right_mono SUP_upper x)
   next
     have "?lhs / ereal x = (SUP i\<in>Y. f i) * (ereal x / ereal x)" by(simp only: ereal_times_divide_eq)
     also have "\<dots> = (SUP i\<in>Y. f i)" using False by simp
     also have "\<dots> \<le> ?rhs / x"
     proof(rule SUP_least)
       fix i
       assume "i \<in> Y"
       have "f i = f i * (ereal x / ereal x)" using False by simp
       also have "\<dots> = f i * x / x" by(simp only: ereal_times_divide_eq)
       also from \<open>i \<in> Y\<close> have "f i * x \<le> ?rhs" by(rule SUP_upper)
       hence "f i * x / x \<le> ?rhs / x" using x False by simp
       finally show "f i \<le> ?rhs / x" .
     qed
     finally have "(?lhs / x) * x \<le> (?rhs / x) * x"
       by(rule ereal_mult_right_mono)(simp add: x)
     also have "\<dots> = ?rhs" using False ereal_divide_eq mult.commute by force
     also have "(?lhs / x) * x = ?lhs" using False ereal_divide_eq mult.commute by force
     finally show "?lhs \<le> ?rhs" .
   qed
 qed
 
 lemma Sup_ereal_mult_left':
   "\<lbrakk> Y \<noteq> {}; x \<ge> 0 \<rbrakk> \<Longrightarrow> ereal x * (SUP i\<in>Y. f i) = (SUP i\<in>Y. ereal x * f i)"
 by(subst (1 2) mult.commute)(rule Sup_ereal_mult_right')
 
 lemma sup_continuous_add[order_continuous_intros]:
   fixes f g :: "'a::complete_lattice \<Rightarrow> ereal"
   assumes nn: "\<And>x. 0 \<le> f x" "\<And>x. 0 \<le> g x" and cont: "sup_continuous f" "sup_continuous g"
   shows "sup_continuous (\<lambda>x. f x + g x)"
   unfolding sup_continuous_def
 proof safe
   fix M :: "nat \<Rightarrow> 'a" assume "incseq M"
   then show "f (SUP i. M i) + g (SUP i. M i) = (SUP i. f (M i) + g (M i))"
     using SUP_ereal_add_pos[of "\<lambda>i. f (M i)" "\<lambda>i. g (M i)"] nn
       cont[THEN sup_continuous_mono] cont[THEN sup_continuousD]
     by (auto simp: mono_def)
 qed
 
 lemma sup_continuous_mult_right[order_continuous_intros]:
   "0 \<le> c \<Longrightarrow> c < \<infinity> \<Longrightarrow> sup_continuous f \<Longrightarrow> sup_continuous (\<lambda>x. f x * c :: ereal)"
   by (cases c) (auto simp: sup_continuous_def fun_eq_iff Sup_ereal_mult_right')
 
 lemma sup_continuous_mult_left[order_continuous_intros]:
   "0 \<le> c \<Longrightarrow> c < \<infinity> \<Longrightarrow> sup_continuous f \<Longrightarrow> sup_continuous (\<lambda>x. c * f x :: ereal)"
   using sup_continuous_mult_right[of c f] by (simp add: mult_ac)
 
 lemma sup_continuous_ereal_of_enat[order_continuous_intros]:
   assumes f: "sup_continuous f" shows "sup_continuous (\<lambda>x. ereal_of_enat (f x))"
   by (rule sup_continuous_compose[OF _ f])
      (auto simp: sup_continuous_def ereal_of_enat_SUP)
 
 subsubsection \<open>Sums\<close>
 
 lemma sums_ereal_positive:
   fixes f :: "nat \<Rightarrow> ereal"
   assumes "\<And>i. 0 \<le> f i"
   shows "f sums (SUP n. \<Sum>i<n. f i)"
 proof -
   have "incseq (\<lambda>i. \<Sum>j=0..<i. f j)"
     using add_mono[OF _ assms]
     by (auto intro!: incseq_SucI)
   from LIMSEQ_SUP[OF this]
   show ?thesis unfolding sums_def
     by (simp add: atLeast0LessThan)
 qed
 
 lemma summable_ereal_pos:
   fixes f :: "nat \<Rightarrow> ereal"
   assumes "\<And>i. 0 \<le> f i"
   shows "summable f"
   using sums_ereal_positive[of f, OF assms]
   unfolding summable_def
   by auto
 
 lemma sums_ereal: "(\<lambda>x. ereal (f x)) sums ereal x \<longleftrightarrow> f sums x"
   unfolding sums_def by simp
 
 lemma suminf_ereal_eq_SUP:
   fixes f :: "nat \<Rightarrow> ereal"
   assumes "\<And>i. 0 \<le> f i"
   shows "(\<Sum>x. f x) = (SUP n. \<Sum>i<n. f i)"
   using sums_ereal_positive[of f, OF assms, THEN sums_unique]
   by simp
 
 lemma suminf_bound:
   fixes f :: "nat \<Rightarrow> ereal"
   assumes "\<forall>N. (\<Sum>n<N. f n) \<le> x"
     and pos: "\<And>n. 0 \<le> f n"
   shows "suminf f \<le> x"
 proof (rule Lim_bounded)
   have "summable f" using pos[THEN summable_ereal_pos] .
   then show "(\<lambda>N. \<Sum>n<N. f n) \<longlonglongrightarrow> suminf f"
     by (auto dest!: summable_sums simp: sums_def atLeast0LessThan)
   show "\<forall>n\<ge>0. sum f {..<n} \<le> x"
     using assms by auto
 qed
 
 lemma suminf_bound_add:
   fixes f :: "nat \<Rightarrow> ereal"
   assumes "\<forall>N. (\<Sum>n<N. f n) + y \<le> x"
     and pos: "\<And>n. 0 \<le> f n"
     and "y \<noteq> -\<infinity>"
   shows "suminf f + y \<le> x"
 proof (cases y)
   case (real r)
   then have "\<forall>N. (\<Sum>n<N. f n) \<le> x - y"
     using assms by (simp add: ereal_le_minus)
   then have "(\<Sum> n. f n) \<le> x - y"
     using pos by (rule suminf_bound)
   then show "(\<Sum> n. f n) + y \<le> x"
     using assms real by (simp add: ereal_le_minus)
 qed (insert assms, auto)
 
 lemma suminf_upper:
   fixes f :: "nat \<Rightarrow> ereal"
   assumes "\<And>n. 0 \<le> f n"
   shows "(\<Sum>n<N. f n) \<le> (\<Sum>n. f n)"
   unfolding suminf_ereal_eq_SUP [OF assms]
   by (auto intro: complete_lattice_class.SUP_upper)
 
 lemma suminf_0_le:
   fixes f :: "nat \<Rightarrow> ereal"
   assumes "\<And>n. 0 \<le> f n"
   shows "0 \<le> (\<Sum>n. f n)"
   using suminf_upper[of f 0, OF assms]
   by simp
 
 lemma suminf_le_pos:
   fixes f g :: "nat \<Rightarrow> ereal"
   assumes "\<And>N. f N \<le> g N"
     and "\<And>N. 0 \<le> f N"
   shows "suminf f \<le> suminf g"
 proof (safe intro!: suminf_bound)
   fix n
   {
     fix N
     have "0 \<le> g N"
       using assms(2,1)[of N] by auto
   }
   have "sum f {..<n} \<le> sum g {..<n}"
     using assms by (auto intro: sum_mono)
   also have "\<dots> \<le> suminf g"
     using \<open>\<And>N. 0 \<le> g N\<close>
     by (rule suminf_upper)
   finally show "sum f {..<n} \<le> suminf g" .
 qed (rule assms(2))
 
 lemma suminf_half_series_ereal: "(\<Sum>n. (1/2 :: ereal) ^ Suc n) = 1"
   using sums_ereal[THEN iffD2, OF power_half_series, THEN sums_unique, symmetric]
   by (simp add: one_ereal_def)
 
 lemma suminf_add_ereal:
   fixes f g :: "nat \<Rightarrow> ereal"
   assumes "\<And>i. 0 \<le> f i" "\<And>i. 0 \<le> g i"
   shows "(\<Sum>i. f i + g i) = suminf f + suminf g"
 proof -
   have "(SUP n. \<Sum>i<n. f i + g i) = (SUP n. sum f {..<n}) + (SUP n. sum g {..<n})"
     unfolding sum.distrib
     by (intro assms add_nonneg_nonneg SUP_ereal_add_pos incseq_sumI sum_nonneg ballI)
   with assms show ?thesis
     by (subst (1 2 3) suminf_ereal_eq_SUP) auto
 qed
 
 lemma suminf_cmult_ereal:
   fixes f g :: "nat \<Rightarrow> ereal"
   assumes "\<And>i. 0 \<le> f i"
     and "0 \<le> a"
   shows "(\<Sum>i. a * f i) = a * suminf f"
   by (auto simp: sum_ereal_right_distrib[symmetric] assms
        ereal_zero_le_0_iff sum_nonneg suminf_ereal_eq_SUP
        intro!: SUP_ereal_mult_left)
 
 lemma suminf_PInfty:
   fixes f :: "nat \<Rightarrow> ereal"
   assumes "\<And>i. 0 \<le> f i"
     and "suminf f \<noteq> \<infinity>"
   shows "f i \<noteq> \<infinity>"
 proof -
   from suminf_upper[of f "Suc i", OF assms(1)] assms(2)
   have "(\<Sum>i<Suc i. f i) \<noteq> \<infinity>"
     by auto
   then show ?thesis
     unfolding sum_Pinfty by simp
 qed
 
 lemma suminf_PInfty_fun:
   assumes "\<And>i. 0 \<le> f i"
     and "suminf f \<noteq> \<infinity>"
   shows "\<exists>f'. f = (\<lambda>x. ereal (f' x))"
 proof -
   have "\<forall>i. \<exists>r. f i = ereal r"
   proof
     fix i
     show "\<exists>r. f i = ereal r"
       using suminf_PInfty[OF assms] assms(1)[of i]
       by (cases "f i") auto
   qed
   from choice[OF this] show ?thesis
     by auto
 qed
 
 lemma summable_ereal:
   assumes "\<And>i. 0 \<le> f i"
     and "(\<Sum>i. ereal (f i)) \<noteq> \<infinity>"
   shows "summable f"
 proof -
   have "0 \<le> (\<Sum>i. ereal (f i))"
     using assms by (intro suminf_0_le) auto
   with assms obtain r where r: "(\<Sum>i. ereal (f i)) = ereal r"
     by (cases "\<Sum>i. ereal (f i)") auto
   from summable_ereal_pos[of "\<lambda>x. ereal (f x)"]
   have "summable (\<lambda>x. ereal (f x))"
     using assms by auto
   from summable_sums[OF this]
   have "(\<lambda>x. ereal (f x)) sums (\<Sum>x. ereal (f x))"
     by auto
   then show "summable f"
     unfolding r sums_ereal summable_def ..
 qed
 
 lemma suminf_ereal:
   assumes "\<And>i. 0 \<le> f i"
     and "(\<Sum>i. ereal (f i)) \<noteq> \<infinity>"
   shows "(\<Sum>i. ereal (f i)) = ereal (suminf f)"
 proof (rule sums_unique[symmetric])
   from summable_ereal[OF assms]
   show "(\<lambda>x. ereal (f x)) sums (ereal (suminf f))"
     unfolding sums_ereal
     using assms
     by (intro summable_sums summable_ereal)
 qed
 
 lemma suminf_ereal_minus:
   fixes f g :: "nat \<Rightarrow> ereal"
   assumes ord: "\<And>i. g i \<le> f i" "\<And>i. 0 \<le> g i"
     and fin: "suminf f \<noteq> \<infinity>" "suminf g \<noteq> \<infinity>"
   shows "(\<Sum>i. f i - g i) = suminf f - suminf g"
 proof -
   {
     fix i
     have "0 \<le> f i"
       using ord[of i] by auto
   }
   moreover
   from suminf_PInfty_fun[OF \<open>\<And>i. 0 \<le> f i\<close> fin(1)] obtain f' where [simp]: "f = (\<lambda>x. ereal (f' x))" ..
   from suminf_PInfty_fun[OF \<open>\<And>i. 0 \<le> g i\<close> fin(2)] obtain g' where [simp]: "g = (\<lambda>x. ereal (g' x))" ..
   {
     fix i
     have "0 \<le> f i - g i"
       using ord[of i] by (auto simp: ereal_le_minus_iff)
   }
   moreover
   have "suminf (\<lambda>i. f i - g i) \<le> suminf f"
     using assms by (auto intro!: suminf_le_pos simp: field_simps)
   then have "suminf (\<lambda>i. f i - g i) \<noteq> \<infinity>"
     using fin by auto
   ultimately show ?thesis
     using assms \<open>\<And>i. 0 \<le> f i\<close>
     apply simp
     apply (subst (1 2 3) suminf_ereal)
     apply (auto intro!: suminf_diff[symmetric] summable_ereal)
     done
 qed
 
 lemma suminf_ereal_PInf [simp]: "(\<Sum>x. \<infinity>::ereal) = \<infinity>"
 proof -
   have "(\<Sum>i<Suc 0. \<infinity>) \<le> (\<Sum>x. \<infinity>::ereal)"
     by (rule suminf_upper) auto
   then show ?thesis
     by simp
 qed
 
 lemma summable_real_of_ereal:
   fixes f :: "nat \<Rightarrow> ereal"
   assumes f: "\<And>i. 0 \<le> f i"
     and fin: "(\<Sum>i. f i) \<noteq> \<infinity>"
   shows "summable (\<lambda>i. real_of_ereal (f i))"
 proof (rule summable_def[THEN iffD2])
   have "0 \<le> (\<Sum>i. f i)"
     using assms by (auto intro: suminf_0_le)
   with fin obtain r where r: "ereal r = (\<Sum>i. f i)"
     by (cases "(\<Sum>i. f i)") auto
   {
     fix i
     have "f i \<noteq> \<infinity>"
       using f by (intro suminf_PInfty[OF _ fin]) auto
     then have "\<bar>f i\<bar> \<noteq> \<infinity>"
       using f[of i] by auto
   }
   note fin = this
   have "(\<lambda>i. ereal (real_of_ereal (f i))) sums (\<Sum>i. ereal (real_of_ereal (f i)))"
     using f
     by (auto intro!: summable_ereal_pos simp: ereal_le_real_iff zero_ereal_def)
   also have "\<dots> = ereal r"
     using fin r by (auto simp: ereal_real)
   finally show "\<exists>r. (\<lambda>i. real_of_ereal (f i)) sums r"
     by (auto simp: sums_ereal)
 qed
 
 lemma suminf_SUP_eq:
   fixes f :: "nat \<Rightarrow> nat \<Rightarrow> ereal"
   assumes "\<And>i. incseq (\<lambda>n. f n i)"
     and "\<And>n i. 0 \<le> f n i"
   shows "(\<Sum>i. SUP n. f n i) = (SUP n. \<Sum>i. f n i)"
 proof -
   have *: "\<And>n. (\<Sum>i<n. SUP k. f k i) = (SUP k. \<Sum>i<n. f k i)"
     using assms
     by (auto intro!: SUP_ereal_sum [symmetric])
   show ?thesis
     using assms
     apply (subst (1 2) suminf_ereal_eq_SUP)
     apply (auto intro!: SUP_upper2 SUP_commute simp: *)
     done
 qed
 
 lemma suminf_sum_ereal:
   fixes f :: "_ \<Rightarrow> _ \<Rightarrow> ereal"
   assumes nonneg: "\<And>i a. a \<in> A \<Longrightarrow> 0 \<le> f i a"
   shows "(\<Sum>i. \<Sum>a\<in>A. f i a) = (\<Sum>a\<in>A. \<Sum>i. f i a)"
 proof (cases "finite A")
   case True
   then show ?thesis
     using nonneg
     by induct (simp_all add: suminf_add_ereal sum_nonneg)
 next
   case False
   then show ?thesis by simp
 qed
 
 lemma suminf_ereal_eq_0:
   fixes f :: "nat \<Rightarrow> ereal"
   assumes nneg: "\<And>i. 0 \<le> f i"
   shows "(\<Sum>i. f i) = 0 \<longleftrightarrow> (\<forall>i. f i = 0)"
 proof
   assume "(\<Sum>i. f i) = 0"
   {
     fix i
     assume "f i \<noteq> 0"
     with nneg have "0 < f i"
       by (auto simp: less_le)
     also have "f i = (\<Sum>j. if j = i then f i else 0)"
       by (subst suminf_finite[where N="{i}"]) auto
     also have "\<dots> \<le> (\<Sum>i. f i)"
       using nneg
       by (auto intro!: suminf_le_pos)
     finally have False
       using \<open>(\<Sum>i. f i) = 0\<close> by auto
   }
   then show "\<forall>i. f i = 0"
     by auto
 qed simp
 
 lemma suminf_ereal_offset_le:
   fixes f :: "nat \<Rightarrow> ereal"
   assumes f: "\<And>i. 0 \<le> f i"
   shows "(\<Sum>i. f (i + k)) \<le> suminf f"
 proof -
   have "(\<lambda>n. \<Sum>i<n. f (i + k)) \<longlonglongrightarrow> (\<Sum>i. f (i + k))"
     using summable_sums[OF summable_ereal_pos]
     by (simp add: sums_def atLeast0LessThan f)
   moreover have "(\<lambda>n. \<Sum>i<n. f i) \<longlonglongrightarrow> (\<Sum>i. f i)"
     using summable_sums[OF summable_ereal_pos]
     by (simp add: sums_def atLeast0LessThan f)
   then have "(\<lambda>n. \<Sum>i<n + k. f i) \<longlonglongrightarrow> (\<Sum>i. f i)"
     by (rule LIMSEQ_ignore_initial_segment)
   ultimately show ?thesis
   proof (rule LIMSEQ_le, safe intro!: exI[of _ k])
     fix n assume "k \<le> n"
     have "(\<Sum>i<n. f (i + k)) = (\<Sum>i<n. (f \<circ> plus k) i)"
       by (simp add: ac_simps)
     also have "\<dots> = (\<Sum>i\<in>(plus k) ` {..<n}. f i)"
       by (rule sum.reindex [symmetric]) simp
     also have "\<dots> \<le> sum f {..<n + k}"
       by (intro sum_mono2) (auto simp: f)
     finally show "(\<Sum>i<n. f (i + k)) \<le> sum f {..<n + k}" .
   qed
 qed
 
 lemma sums_suminf_ereal: "f sums x \<Longrightarrow> (\<Sum>i. ereal (f i)) = ereal x"
   by (metis sums_ereal sums_unique)
 
 lemma suminf_ereal': "summable f \<Longrightarrow> (\<Sum>i. ereal (f i)) = ereal (\<Sum>i. f i)"
   by (metis sums_ereal sums_unique summable_def)
 
 lemma suminf_ereal_finite: "summable f \<Longrightarrow> (\<Sum>i. ereal (f i)) \<noteq> \<infinity>"
   by (auto simp: summable_def simp flip: sums_ereal sums_unique)
 
 lemma suminf_ereal_finite_neg:
   assumes "summable f"
   shows "(\<Sum>x. ereal (f x)) \<noteq> -\<infinity>"
 proof-
   from assms obtain x where "f sums x" by blast
   hence "(\<lambda>x. ereal (f x)) sums ereal x" by (simp add: sums_ereal)
   from sums_unique[OF this] have "(\<Sum>x. ereal (f x)) = ereal x" ..
   thus "(\<Sum>x. ereal (f x)) \<noteq> -\<infinity>" by simp_all
 qed
 
 lemma SUP_ereal_add_directed:
   fixes f g :: "'a \<Rightarrow> ereal"
   assumes nonneg: "\<And>i. i \<in> I \<Longrightarrow> 0 \<le> f i" "\<And>i. i \<in> I \<Longrightarrow> 0 \<le> g i"
   assumes directed: "\<And>i j. i \<in> I \<Longrightarrow> j \<in> I \<Longrightarrow> \<exists>k\<in>I. f i + g j \<le> f k + g k"
   shows "(SUP i\<in>I. f i + g i) = (SUP i\<in>I. f i) + (SUP i\<in>I. g i)"
 proof cases
   assume "I = {}" then show ?thesis
     by (simp add: bot_ereal_def)
 next
   assume "I \<noteq> {}"
   show ?thesis
   proof (rule antisym)
     show "(SUP i\<in>I. f i + g i) \<le> (SUP i\<in>I. f i) + (SUP i\<in>I. g i)"
       by (rule SUP_least; intro add_mono SUP_upper)
   next
     have "bot < (SUP i\<in>I. g i)"
       using \<open>I \<noteq> {}\<close> nonneg(2) by (auto simp: bot_ereal_def less_SUP_iff)
     then have "(SUP i\<in>I. f i) + (SUP i\<in>I. g i) = (SUP i\<in>I. f i + (SUP i\<in>I. g i))"
       by (intro SUP_ereal_add_left[symmetric] \<open>I \<noteq> {}\<close>) auto
     also have "\<dots> = (SUP i\<in>I. (SUP j\<in>I. f i + g j))"
       using nonneg(1) \<open>I \<noteq> {}\<close> by (simp add: SUP_ereal_add_right)
     also have "\<dots> \<le> (SUP i\<in>I. f i + g i)"
       using directed by (intro SUP_least) (blast intro: SUP_upper2)
     finally show "(SUP i\<in>I. f i) + (SUP i\<in>I. g i) \<le> (SUP i\<in>I. f i + g i)" .
   qed
 qed
 
 lemma SUP_ereal_sum_directed:
   fixes f g :: "'a \<Rightarrow> 'b \<Rightarrow> ereal"
   assumes "I \<noteq> {}"
   assumes directed: "\<And>N i j. N \<subseteq> A \<Longrightarrow> i \<in> I \<Longrightarrow> j \<in> I \<Longrightarrow> \<exists>k\<in>I. \<forall>n\<in>N. f n i \<le> f n k \<and> f n j \<le> f n k"
   assumes nonneg: "\<And>n i. i \<in> I \<Longrightarrow> n \<in> A \<Longrightarrow> 0 \<le> f n i"
   shows "(SUP i\<in>I. \<Sum>n\<in>A. f n i) = (\<Sum>n\<in>A. SUP i\<in>I. f n i)"
 proof -
   have "N \<subseteq> A \<Longrightarrow> (SUP i\<in>I. \<Sum>n\<in>N. f n i) = (\<Sum>n\<in>N. SUP i\<in>I. f n i)" for N
   proof (induction N rule: infinite_finite_induct)
     case (insert n N)
-    moreover have "(SUP i\<in>I. f n i + (\<Sum>l\<in>N. f l i)) = (SUP i\<in>I. f n i) + (SUP i\<in>I. \<Sum>l\<in>N. f l i)"
+    have "(SUP i\<in>I. f n i + (\<Sum>l\<in>N. f l i)) = (SUP i\<in>I. f n i) + (SUP i\<in>I. \<Sum>l\<in>N. f l i)"
     proof (rule SUP_ereal_add_directed)
       fix i assume "i \<in> I" then show "0 \<le> f n i" "0 \<le> (\<Sum>l\<in>N. f l i)"
         using insert by (auto intro!: sum_nonneg nonneg)
     next
       fix i j assume "i \<in> I" "j \<in> I"
-      from directed[OF \<open>insert n N \<subseteq> A\<close> this] guess k ..
-      then show "\<exists>k\<in>I. f n i + (\<Sum>l\<in>N. f l j) \<le> f n k + (\<Sum>l\<in>N. f l k)"
-        by (intro bexI[of _ k]) (auto intro!: add_mono sum_mono)
+      from directed[OF insert(4) this]
+      show "\<exists>k\<in>I. f n i + (\<Sum>l\<in>N. f l j) \<le> f n k + (\<Sum>l\<in>N. f l k)"
+        by (auto intro!: add_mono sum_mono)
     qed
-    ultimately show ?case
+    with insert show ?case
       by simp
   qed (simp_all add: SUP_constant \<open>I \<noteq> {}\<close>)
   from this[of A] show ?thesis by simp
 qed
 
 lemma suminf_SUP_eq_directed:
   fixes f :: "_ \<Rightarrow> nat \<Rightarrow> ereal"
   assumes "I \<noteq> {}"
   assumes directed: "\<And>N i j. i \<in> I \<Longrightarrow> j \<in> I \<Longrightarrow> finite N \<Longrightarrow> \<exists>k\<in>I. \<forall>n\<in>N. f i n \<le> f k n \<and> f j n \<le> f k n"
   assumes nonneg: "\<And>n i. 0 \<le> f n i"
   shows "(\<Sum>i. SUP n\<in>I. f n i) = (SUP n\<in>I. \<Sum>i. f n i)"
 proof (subst (1 2) suminf_ereal_eq_SUP)
   show "\<And>n i. 0 \<le> f n i" "\<And>i. 0 \<le> (SUP n\<in>I. f n i)"
     using \<open>I \<noteq> {}\<close> nonneg by (auto intro: SUP_upper2)
   show "(SUP n. \<Sum>i<n. SUP n\<in>I. f n i) = (SUP n\<in>I. SUP j. \<Sum>i<j. f n i)"
     by (auto simp: finite_subset SUP_commute SUP_ereal_sum_directed assms)
 qed
 
 lemma ereal_dense3:
   fixes x y :: ereal
   shows "x < y \<Longrightarrow> \<exists>r::rat. x < real_of_rat r \<and> real_of_rat r < y"
 proof (cases x y rule: ereal2_cases, simp_all)
   fix r q :: real
   assume "r < q"
   from Rats_dense_in_real[OF this] show "\<exists>x. r < real_of_rat x \<and> real_of_rat x < q"
     by (fastforce simp: Rats_def)
 next
   fix r :: real
   show "\<exists>x. r < real_of_rat x" "\<exists>x. real_of_rat x < r"
     using gt_ex[of r] lt_ex[of r] Rats_dense_in_real
     by (auto simp: Rats_def)
 qed
 
 lemma continuous_within_ereal[intro, simp]: "x \<in> A \<Longrightarrow> continuous (at x within A) ereal"
   using continuous_on_eq_continuous_within[of A ereal]
   by (auto intro: continuous_on_ereal continuous_on_id)
 
 lemma ereal_open_uminus:
   fixes S :: "ereal set"
   assumes "open S"
   shows "open (uminus ` S)"
   using \<open>open S\<close>[unfolded open_generated_order]
 proof induct
   have "range uminus = (UNIV :: ereal set)"
     by (auto simp: image_iff ereal_uminus_eq_reorder)
   then show "open (range uminus :: ereal set)"
     by simp
 qed (auto simp add: image_Union image_Int)
 
 lemma ereal_uminus_complement:
   fixes S :: "ereal set"
   shows "uminus ` (- S) = - uminus ` S"
   by (auto intro!: bij_image_Compl_eq surjI[of _ uminus] simp: bij_betw_def)
 
 lemma ereal_closed_uminus:
   fixes S :: "ereal set"
   assumes "closed S"
   shows "closed (uminus ` S)"
   using assms
   unfolding closed_def ereal_uminus_complement[symmetric]
   by (rule ereal_open_uminus)
 
 lemma ereal_open_affinity_pos:
   fixes S :: "ereal set"
   assumes "open S"
     and m: "m \<noteq> \<infinity>" "0 < m"
     and t: "\<bar>t\<bar> \<noteq> \<infinity>"
   shows "open ((\<lambda>x. m * x + t) ` S)"
 proof -
   have "continuous_on UNIV (\<lambda>x. inverse m * (x + - t))"
     using m t
     by (intro continuous_at_imp_continuous_on ballI continuous_at[THEN iffD2]; force)
   then have "open ((\<lambda>x. inverse m * (x + -t)) -` S)"
     using \<open>open S\<close> open_vimage by blast
   also have "(\<lambda>x. inverse m * (x + -t)) -` S = (\<lambda>x. (x - t) / m) -` S"
     using m t by (auto simp: divide_ereal_def mult.commute minus_ereal_def
                        simp flip: uminus_ereal.simps)
   also have "(\<lambda>x. (x - t) / m) -` S = (\<lambda>x. m * x + t) ` S"
     using m t
     by (simp add: set_eq_iff image_iff)
        (metis abs_ereal_less0 abs_ereal_uminus ereal_divide_eq ereal_eq_minus ereal_minus(7,8)
               ereal_minus_less_minus ereal_mult_eq_PInfty ereal_uminus_uminus ereal_zero_mult)
   finally show ?thesis .
 qed
 
 lemma ereal_open_affinity:
   fixes S :: "ereal set"
   assumes "open S"
     and m: "\<bar>m\<bar> \<noteq> \<infinity>" "m \<noteq> 0"
     and t: "\<bar>t\<bar> \<noteq> \<infinity>"
   shows "open ((\<lambda>x. m * x + t) ` S)"
 proof cases
   assume "0 < m"
   then show ?thesis
     using ereal_open_affinity_pos[OF \<open>open S\<close> _ _ t, of m] m
     by auto
 next
   assume "\<not> 0 < m" then
   have "0 < -m"
     using \<open>m \<noteq> 0\<close>
     by (cases m) auto
   then have m: "-m \<noteq> \<infinity>" "0 < -m"
     using \<open>\<bar>m\<bar> \<noteq> \<infinity>\<close>
     by (auto simp: ereal_uminus_eq_reorder)
   from ereal_open_affinity_pos[OF ereal_open_uminus[OF \<open>open S\<close>] m t] show ?thesis
     unfolding image_image by simp
 qed
 
 lemma open_uminus_iff:
   fixes S :: "ereal set"
   shows "open (uminus ` S) \<longleftrightarrow> open S"
   using ereal_open_uminus[of S] ereal_open_uminus[of "uminus ` S"]
   by auto
 
 lemma ereal_Liminf_uminus:
   fixes f :: "'a \<Rightarrow> ereal"
   shows "Liminf net (\<lambda>x. - (f x)) = - Limsup net f"
   using ereal_Limsup_uminus[of _ "(\<lambda>x. - (f x))"] by auto
 
 lemma Liminf_PInfty:
   fixes f :: "'a \<Rightarrow> ereal"
   assumes "\<not> trivial_limit net"
   shows "(f \<longlongrightarrow> \<infinity>) net \<longleftrightarrow> Liminf net f = \<infinity>"
   unfolding tendsto_iff_Liminf_eq_Limsup[OF assms]
   using Liminf_le_Limsup[OF assms, of f]
   by auto
 
 lemma Limsup_MInfty:
   fixes f :: "'a \<Rightarrow> ereal"
   assumes "\<not> trivial_limit net"
   shows "(f \<longlongrightarrow> -\<infinity>) net \<longleftrightarrow> Limsup net f = -\<infinity>"
   unfolding tendsto_iff_Liminf_eq_Limsup[OF assms]
   using Liminf_le_Limsup[OF assms, of f]
   by auto
 
 lemma convergent_ereal: \<comment> \<open>RENAME\<close>
   fixes X :: "nat \<Rightarrow> 'a :: {complete_linorder,linorder_topology}"
   shows "convergent X \<longleftrightarrow> limsup X = liminf X"
   using tendsto_iff_Liminf_eq_Limsup[of sequentially]
   by (auto simp: convergent_def)
 
 lemma limsup_le_liminf_real:
   fixes X :: "nat \<Rightarrow> real" and L :: real
   assumes 1: "limsup X \<le> L" and 2: "L \<le> liminf X"
   shows "X \<longlonglongrightarrow> L"
 proof -
   from 1 2 have "limsup X \<le> liminf X" by auto
   hence 3: "limsup X = liminf X"
     by (simp add: Liminf_le_Limsup order_class.order.antisym)
   hence 4: "convergent (\<lambda>n. ereal (X n))"
     by (subst convergent_ereal)
   hence "limsup X = lim (\<lambda>n. ereal(X n))"
     by (rule convergent_limsup_cl)
   also from 1 2 3 have "limsup X = L" by auto
   finally have "lim (\<lambda>n. ereal(X n)) = L" ..
   hence "(\<lambda>n. ereal (X n)) \<longlonglongrightarrow> L"
     using "4" convergent_LIMSEQ_iff by force
   thus ?thesis by simp
 qed
 
 lemma liminf_PInfty:
   fixes X :: "nat \<Rightarrow> ereal"
   shows "X \<longlonglongrightarrow> \<infinity> \<longleftrightarrow> liminf X = \<infinity>"
   by (metis Liminf_PInfty trivial_limit_sequentially)
 
 lemma limsup_MInfty:
   fixes X :: "nat \<Rightarrow> ereal"
   shows "X \<longlonglongrightarrow> -\<infinity> \<longleftrightarrow> limsup X = -\<infinity>"
   by (metis Limsup_MInfty trivial_limit_sequentially)
 
 lemma SUP_eq_LIMSEQ:
   assumes "mono f"
   shows "(SUP n. ereal (f n)) = ereal x \<longleftrightarrow> f \<longlonglongrightarrow> x"
 proof
   have inc: "incseq (\<lambda>i. ereal (f i))"
     using \<open>mono f\<close> unfolding mono_def incseq_def by auto
   {
     assume "f \<longlonglongrightarrow> x"
     then have "(\<lambda>i. ereal (f i)) \<longlonglongrightarrow> ereal x"
       by auto
     from SUP_Lim[OF inc this] show "(SUP n. ereal (f n)) = ereal x" .
   next
     assume "(SUP n. ereal (f n)) = ereal x"
     with LIMSEQ_SUP[OF inc] show "f \<longlonglongrightarrow> x" by auto
   }
 qed
 
 lemma liminf_ereal_cminus:
   fixes f :: "nat \<Rightarrow> ereal"
   assumes "c \<noteq> -\<infinity>"
   shows "liminf (\<lambda>x. c - f x) = c - limsup f"
 proof (cases c)
   case PInf
   then show ?thesis
     by (simp add: Liminf_const)
 next
   case (real r)
   then show ?thesis
     by (simp add: liminf_SUP_INF limsup_INF_SUP INF_ereal_minus_right SUP_ereal_minus_right)
 qed (use \<open>c \<noteq> -\<infinity>\<close> in simp)
 
 
 subsubsection \<open>Continuity\<close>
 
 lemma continuous_at_of_ereal:
   "\<bar>x0 :: ereal\<bar> \<noteq> \<infinity> \<Longrightarrow> continuous (at x0) real_of_ereal"
   unfolding continuous_at
   by (rule lim_real_of_ereal) (simp add: ereal_real)
 
 lemma nhds_ereal: "nhds (ereal r) = filtermap ereal (nhds r)"
   by (simp add: filtermap_nhds_open_map open_ereal continuous_at_of_ereal)
 
 lemma at_ereal: "at (ereal r) = filtermap ereal (at r)"
   by (simp add: filter_eq_iff eventually_at_filter nhds_ereal eventually_filtermap)
 
 lemma at_left_ereal: "at_left (ereal r) = filtermap ereal (at_left r)"
   by (simp add: filter_eq_iff eventually_at_filter nhds_ereal eventually_filtermap)
 
 lemma at_right_ereal: "at_right (ereal r) = filtermap ereal (at_right r)"
   by (simp add: filter_eq_iff eventually_at_filter nhds_ereal eventually_filtermap)
 
 lemma
   shows at_left_PInf: "at_left \<infinity> = filtermap ereal at_top"
     and at_right_MInf: "at_right (-\<infinity>) = filtermap ereal at_bot"
   unfolding filter_eq_iff eventually_filtermap eventually_at_top_dense eventually_at_bot_dense
     eventually_at_left[OF ereal_less(5)] eventually_at_right[OF ereal_less(6)]
   by (auto simp add: ereal_all_split ereal_ex_split)
 
 lemma ereal_tendsto_simps1:
   "((f \<circ> real_of_ereal) \<longlongrightarrow> y) (at_left (ereal x)) \<longleftrightarrow> (f \<longlongrightarrow> y) (at_left x)"
   "((f \<circ> real_of_ereal) \<longlongrightarrow> y) (at_right (ereal x)) \<longleftrightarrow> (f \<longlongrightarrow> y) (at_right x)"
   "((f \<circ> real_of_ereal) \<longlongrightarrow> y) (at_left (\<infinity>::ereal)) \<longleftrightarrow> (f \<longlongrightarrow> y) at_top"
   "((f \<circ> real_of_ereal) \<longlongrightarrow> y) (at_right (-\<infinity>::ereal)) \<longleftrightarrow> (f \<longlongrightarrow> y) at_bot"
   unfolding tendsto_compose_filtermap at_left_ereal at_right_ereal at_left_PInf at_right_MInf
   by (auto simp: filtermap_filtermap filtermap_ident)
 
 lemma ereal_tendsto_simps2:
   "((ereal \<circ> f) \<longlongrightarrow> ereal a) F \<longleftrightarrow> (f \<longlongrightarrow> a) F"
   "((ereal \<circ> f) \<longlongrightarrow> \<infinity>) F \<longleftrightarrow> (LIM x F. f x :> at_top)"
   "((ereal \<circ> f) \<longlongrightarrow> -\<infinity>) F \<longleftrightarrow> (LIM x F. f x :> at_bot)"
   unfolding tendsto_PInfty filterlim_at_top_dense tendsto_MInfty filterlim_at_bot_dense
   using lim_ereal by (simp_all add: comp_def)
 
 lemma inverse_infty_ereal_tendsto_0: "inverse \<midarrow>\<infinity>\<rightarrow> (0::ereal)"
 proof -
   have **: "((\<lambda>x. ereal (inverse x)) \<longlongrightarrow> ereal 0) at_infinity"
     by (intro tendsto_intros tendsto_inverse_0)
   then have "((\<lambda>x. if x = 0 then \<infinity> else ereal (inverse x)) \<longlongrightarrow> 0) at_top"
   proof (rule filterlim_mono_eventually)
     show "nhds (ereal 0) \<le> nhds 0"
       by (simp add: zero_ereal_def)
     show "(at_top::real filter) \<le> at_infinity"
       by (simp add: at_top_le_at_infinity)
   qed auto
   then show ?thesis
     unfolding at_infty_ereal_eq_at_top tendsto_compose_filtermap[symmetric] comp_def by auto
 qed
 
 lemma inverse_ereal_tendsto_pos:
   fixes x :: ereal assumes "0 < x"
   shows "inverse \<midarrow>x\<rightarrow> inverse x"
 proof (cases x)
   case (real r)
   with \<open>0 < x\<close> have **: "(\<lambda>x. ereal (inverse x)) \<midarrow>r\<rightarrow> ereal (inverse r)"
     by (auto intro!: tendsto_inverse)
   from real \<open>0 < x\<close> show ?thesis
     by (auto simp: at_ereal tendsto_compose_filtermap[symmetric] eventually_at_filter
              intro!: Lim_transform_eventually[OF **] t1_space_nhds)
 qed (insert \<open>0 < x\<close>, auto intro!: inverse_infty_ereal_tendsto_0)
 
 lemma inverse_ereal_tendsto_at_right_0: "(inverse \<longlongrightarrow> \<infinity>) (at_right (0::ereal))"
   unfolding tendsto_compose_filtermap[symmetric] at_right_ereal zero_ereal_def
   by (subst filterlim_cong[OF refl refl, where g="\<lambda>x. ereal (inverse x)"])
      (auto simp: eventually_at_filter tendsto_PInfty_eq_at_top filterlim_inverse_at_top_right)
 
 lemmas ereal_tendsto_simps = ereal_tendsto_simps1 ereal_tendsto_simps2
 
 lemma continuous_at_iff_ereal:
   fixes f :: "'a::t2_space \<Rightarrow> real"
   shows "continuous (at x0 within s) f \<longleftrightarrow> continuous (at x0 within s) (ereal \<circ> f)"
   unfolding continuous_within comp_def lim_ereal ..
 
 lemma continuous_on_iff_ereal:
   fixes f :: "'a::t2_space => real"
   assumes "open A"
   shows "continuous_on A f \<longleftrightarrow> continuous_on A (ereal \<circ> f)"
   unfolding continuous_on_def comp_def lim_ereal ..
 
 lemma continuous_on_real: "continuous_on (UNIV - {\<infinity>, -\<infinity>::ereal}) real_of_ereal"
   using continuous_at_of_ereal continuous_on_eq_continuous_at open_image_ereal
   by auto
 
 lemma continuous_on_iff_real:
   fixes f :: "'a::t2_space \<Rightarrow> ereal"
   assumes "\<And>x. x \<in> A \<Longrightarrow> \<bar>f x\<bar> \<noteq> \<infinity>"
   shows "continuous_on A f \<longleftrightarrow> continuous_on A (real_of_ereal \<circ> f)"
 proof 
   assume L: "continuous_on A f"
   have "f ` A \<subseteq> UNIV - {\<infinity>, -\<infinity>}"
     using assms by force
   then show "continuous_on A (real_of_ereal \<circ> f)"
     by (meson L continuous_on_compose continuous_on_real continuous_on_subset)
 next
   assume R: "continuous_on A (real_of_ereal \<circ> f)"
   then have "continuous_on A (ereal \<circ> (real_of_ereal \<circ> f))"
     by (meson continuous_at_iff_ereal continuous_on_eq_continuous_within)
   then show "continuous_on A f"
     using assms ereal_real' by auto 
 qed
 
 lemma continuous_uminus_ereal [continuous_intros]: "continuous_on (A :: ereal set) uminus"
   unfolding continuous_on_def
   by (intro ballI tendsto_uminus_ereal[of "\<lambda>x. x::ereal"]) simp
 
 lemma ereal_uminus_atMost [simp]: "uminus ` {..(a::ereal)} = {-a..}"
 proof (intro equalityI subsetI)
   fix x :: ereal assume "x \<in> {-a..}"
   hence "-(-x) \<in> uminus ` {..a}" by (intro imageI) (simp add: ereal_uminus_le_reorder)
   thus "x \<in> uminus ` {..a}" by simp
 qed auto
 
 lemma continuous_on_inverse_ereal [continuous_intros]:
   "continuous_on {0::ereal ..} inverse"
   unfolding continuous_on_def
 proof clarsimp
   fix x :: ereal assume "0 \<le> x"
   moreover have "at 0 within {0 ..} = at_right (0::ereal)"
     by (auto simp: filter_eq_iff eventually_at_filter le_less)
   moreover have "at x within {0 ..} = at x" if "0 < x"
     using that by (intro at_within_nhd[of _ "{0<..}"]) auto
   ultimately show "(inverse \<longlongrightarrow> inverse x) (at x within {0..})"
     by (auto simp: le_less inverse_ereal_tendsto_at_right_0 inverse_ereal_tendsto_pos)
 qed
 
 lemma continuous_inverse_ereal_nonpos: "continuous_on ({..<0} :: ereal set) inverse"
 proof (subst continuous_on_cong[OF refl])
   have "continuous_on {(0::ereal)<..} inverse"
     by (rule continuous_on_subset[OF continuous_on_inverse_ereal]) auto
   thus "continuous_on {..<(0::ereal)} (uminus \<circ> inverse \<circ> uminus)"
     by (intro continuous_intros) simp_all
 qed simp
 
 lemma tendsto_inverse_ereal:
   assumes "(f \<longlongrightarrow> (c :: ereal)) F"
   assumes "eventually (\<lambda>x. f x \<ge> 0) F"
   shows   "((\<lambda>x. inverse (f x)) \<longlongrightarrow> inverse c) F"
   by (cases "F = bot")
      (auto intro!: tendsto_lowerbound assms
                    continuous_on_tendsto_compose[OF continuous_on_inverse_ereal])
 
 
 subsubsection \<open>liminf and limsup\<close>
 
 lemma Limsup_ereal_mult_right:
   assumes "F \<noteq> bot" "(c::real) \<ge> 0"
   shows   "Limsup F (\<lambda>n. f n * ereal c) = Limsup F f * ereal c"
 proof (rule Limsup_compose_continuous_mono)
   from assms show "continuous_on UNIV (\<lambda>a. a * ereal c)"
     using tendsto_cmult_ereal[of "ereal c" "\<lambda>x. x" ]
     by (force simp: continuous_on_def mult_ac)
 qed (insert assms, auto simp: mono_def ereal_mult_right_mono)
 
 lemma Liminf_ereal_mult_right:
   assumes "F \<noteq> bot" "(c::real) \<ge> 0"
   shows   "Liminf F (\<lambda>n. f n * ereal c) = Liminf F f * ereal c"
 proof (rule Liminf_compose_continuous_mono)
   from assms show "continuous_on UNIV (\<lambda>a. a * ereal c)"
     using tendsto_cmult_ereal[of "ereal c" "\<lambda>x. x" ]
     by (force simp: continuous_on_def mult_ac)
 qed (use assms in \<open>auto simp: mono_def ereal_mult_right_mono\<close>)
 
 lemma Liminf_ereal_mult_left:
   assumes "F \<noteq> bot" "(c::real) \<ge> 0"
     shows "Liminf F (\<lambda>n. ereal c * f n) = ereal c * Liminf F f"
 using Liminf_ereal_mult_right[OF assms] by (subst (1 2) mult.commute)
 
 lemma Limsup_ereal_mult_left:
   assumes "F \<noteq> bot" "(c::real) \<ge> 0"
   shows   "Limsup F (\<lambda>n. ereal c * f n) = ereal c * Limsup F f"
   using Limsup_ereal_mult_right[OF assms] by (subst (1 2) mult.commute)
 
 lemma limsup_ereal_mult_right:
   "(c::real) \<ge> 0 \<Longrightarrow> limsup (\<lambda>n. f n * ereal c) = limsup f * ereal c"
   by (rule Limsup_ereal_mult_right) simp_all
 
 lemma limsup_ereal_mult_left:
   "(c::real) \<ge> 0 \<Longrightarrow> limsup (\<lambda>n. ereal c * f n) = ereal c * limsup f"
   by (subst (1 2) mult.commute, rule limsup_ereal_mult_right) simp_all
 
 lemma Limsup_add_ereal_right:
   "F \<noteq> bot \<Longrightarrow> abs c \<noteq> \<infinity> \<Longrightarrow> Limsup F (\<lambda>n. g n + (c :: ereal)) = Limsup F g + c"
   by (rule Limsup_compose_continuous_mono) (auto simp: mono_def add_mono continuous_on_def)
 
 lemma Limsup_add_ereal_left:
   "F \<noteq> bot \<Longrightarrow> abs c \<noteq> \<infinity> \<Longrightarrow> Limsup F (\<lambda>n. (c :: ereal) + g n) = c + Limsup F g"
   by (subst (1 2) add.commute) (rule Limsup_add_ereal_right)
 
 lemma Liminf_add_ereal_right:
   "F \<noteq> bot \<Longrightarrow> abs c \<noteq> \<infinity> \<Longrightarrow> Liminf F (\<lambda>n. g n + (c :: ereal)) = Liminf F g + c"
   by (rule Liminf_compose_continuous_mono) (auto simp: mono_def add_mono continuous_on_def)
 
 lemma Liminf_add_ereal_left:
   "F \<noteq> bot \<Longrightarrow> abs c \<noteq> \<infinity> \<Longrightarrow> Liminf F (\<lambda>n. (c :: ereal) + g n) = c + Liminf F g"
   by (subst (1 2) add.commute) (rule Liminf_add_ereal_right)
 
 lemma
   assumes "F \<noteq> bot"
   assumes nonneg: "eventually (\<lambda>x. f x \<ge> (0::ereal)) F"
   shows   Liminf_inverse_ereal: "Liminf F (\<lambda>x. inverse (f x)) = inverse (Limsup F f)"
   and     Limsup_inverse_ereal: "Limsup F (\<lambda>x. inverse (f x)) = inverse (Liminf F f)"
 proof -
   define inv where [abs_def]: "inv x = (if x \<le> 0 then \<infinity> else inverse x)" for x :: ereal
   have "continuous_on ({..0} \<union> {0..}) inv" unfolding inv_def
     by (intro continuous_on_If) (auto intro!: continuous_intros)
   also have "{..0} \<union> {0..} = (UNIV :: ereal set)" by auto
   finally have cont: "continuous_on UNIV inv" .
   have antimono: "antimono inv" unfolding inv_def antimono_def
     by (auto intro!: ereal_inverse_antimono)
 
   have "Liminf F (\<lambda>x. inverse (f x)) = Liminf F (\<lambda>x. inv (f x))" using nonneg
     by (auto intro!: Liminf_eq elim!: eventually_mono simp: inv_def)
   also have "... = inv (Limsup F f)"
     by (simp add: assms(1) Liminf_compose_continuous_antimono[OF cont antimono])
   also from assms have "Limsup F f \<ge> 0" by (intro le_Limsup) simp_all
   hence "inv (Limsup F f) = inverse (Limsup F f)" by (simp add: inv_def)
   finally show "Liminf F (\<lambda>x. inverse (f x)) = inverse (Limsup F f)" .
 
   have "Limsup F (\<lambda>x. inverse (f x)) = Limsup F (\<lambda>x. inv (f x))" using nonneg
     by (auto intro!: Limsup_eq elim!: eventually_mono simp: inv_def)
   also have "... = inv (Liminf F f)"
     by (simp add: assms(1) Limsup_compose_continuous_antimono[OF cont antimono])
   also from assms have "Liminf F f \<ge> 0" by (intro Liminf_bounded) simp_all
   hence "inv (Liminf F f) = inverse (Liminf F f)" by (simp add: inv_def)
   finally show "Limsup F (\<lambda>x. inverse (f x)) = inverse (Liminf F f)" .
 qed
 
 lemma ereal_diff_le_mono_left: "\<lbrakk> x \<le> z; 0 \<le> y \<rbrakk> \<Longrightarrow> x - y \<le> (z :: ereal)"
 by(cases x y z rule: ereal3_cases) simp_all
 
 lemma neg_0_less_iff_less_erea [simp]: "0 < - a \<longleftrightarrow> (a :: ereal) < 0"
 by(cases a) simp_all
 
 lemma not_infty_ereal: "\<bar>x\<bar> \<noteq> \<infinity> \<longleftrightarrow> (\<exists>x'. x = ereal x')"
 by(cases x) simp_all
 
 lemma neq_PInf_trans: fixes x y :: ereal shows "\<lbrakk> y \<noteq> \<infinity>; x \<le> y \<rbrakk> \<Longrightarrow> x \<noteq> \<infinity>"
 by auto
 
 lemma mult_2_ereal: "ereal 2 * x = x + x"
 by(cases x) simp_all
 
 lemma ereal_diff_le_self: "0 \<le> y \<Longrightarrow> x - y \<le> (x :: ereal)"
 by(cases x y rule: ereal2_cases) simp_all
 
 lemma ereal_le_add_self: "0 \<le> y \<Longrightarrow> x \<le> x + (y :: ereal)"
 by(cases x y rule: ereal2_cases) simp_all
 
 lemma ereal_le_add_self2: "0 \<le> y \<Longrightarrow> x \<le> y + (x :: ereal)"
 by(cases x y rule: ereal2_cases) simp_all
 
 lemma ereal_le_add_mono1: "\<lbrakk> x \<le> y; 0 \<le> (z :: ereal) \<rbrakk> \<Longrightarrow> x \<le> y + z"
 using add_mono by fastforce
 
 lemma ereal_le_add_mono2: "\<lbrakk> x \<le> z; 0 \<le> (y :: ereal) \<rbrakk> \<Longrightarrow> x \<le> y + z"
 using add_mono by fastforce
 
 lemma ereal_diff_nonpos:
   fixes a b :: ereal shows "\<lbrakk> a \<le> b; a = \<infinity> \<Longrightarrow> b \<noteq> \<infinity>; a = -\<infinity> \<Longrightarrow> b \<noteq> -\<infinity> \<rbrakk> \<Longrightarrow> a - b \<le> 0"
   by (cases rule: ereal2_cases[of a b]) auto
 
 lemma minus_ereal_0 [simp]: "x - ereal 0 = x"
 by(simp flip: zero_ereal_def)
 
 lemma ereal_diff_eq_0_iff: fixes a b :: ereal
   shows "(\<bar>a\<bar> = \<infinity> \<Longrightarrow> \<bar>b\<bar> \<noteq> \<infinity>) \<Longrightarrow> a - b = 0 \<longleftrightarrow> a = b"
 by(cases a b rule: ereal2_cases) simp_all
 
 lemma SUP_ereal_eq_0_iff_nonneg:
   fixes f :: "_ \<Rightarrow> ereal" and A
   assumes nonneg: "\<forall>x\<in>A. f x \<ge> 0"
   and A:"A \<noteq> {}"
   shows "(SUP x\<in>A. f x) = 0 \<longleftrightarrow> (\<forall>x\<in>A. f x = 0)" (is "?lhs \<longleftrightarrow> ?rhs")
 proof(intro iffI ballI)
   fix x
   assume "?lhs" "x \<in> A"
   from \<open>x \<in> A\<close> have "f x \<le> (SUP x\<in>A. f x)" by(rule SUP_upper)
   with \<open>?lhs\<close> show "f x = 0" using nonneg \<open>x \<in> A\<close> by auto
 qed (simp add: A)
 
 lemma ereal_divide_le_posI:
   fixes x y z :: ereal
   shows "x > 0 \<Longrightarrow> z \<noteq> - \<infinity> \<Longrightarrow> z \<le> x * y \<Longrightarrow> z / x \<le> y"
 by (cases rule: ereal3_cases[of x y z])(auto simp: field_simps split: if_split_asm)
 
 lemma add_diff_eq_ereal: fixes x y z :: ereal
   shows "x + (y - z) = x + y - z"
 by(cases x y z rule: ereal3_cases) simp_all
 
 lemma ereal_diff_gr0:
   fixes a b :: ereal shows "a < b \<Longrightarrow> 0 < b - a"
   by (cases rule: ereal2_cases[of a b]) auto
 
 lemma ereal_minus_minus: fixes x y z :: ereal shows
   "(\<bar>y\<bar> = \<infinity> \<Longrightarrow> \<bar>z\<bar> \<noteq> \<infinity>) \<Longrightarrow> x - (y - z) = x + z - y"
 by(cases x y z rule: ereal3_cases) simp_all
 
 lemma diff_add_eq_ereal: fixes a b c :: ereal shows "a - b + c = a + c - b"
 by(cases a b c rule: ereal3_cases) simp_all
 
 lemma diff_diff_commute_ereal: fixes x y z :: ereal shows "x - y - z = x - z - y"
 by(cases x y z rule: ereal3_cases) simp_all
 
 lemma ereal_diff_eq_MInfty_iff: fixes x y :: ereal shows "x - y = -\<infinity> \<longleftrightarrow> x = -\<infinity> \<and> y \<noteq> -\<infinity> \<or> y = \<infinity> \<and> \<bar>x\<bar> \<noteq> \<infinity>"
 by(cases x y rule: ereal2_cases) simp_all
 
 lemma ereal_diff_add_inverse: fixes x y :: ereal shows "\<bar>x\<bar> \<noteq> \<infinity> \<Longrightarrow> x + y - x = y"
 by(cases x y rule: ereal2_cases) simp_all
 
 lemma tendsto_diff_ereal:
   fixes x y :: ereal
   assumes x: "\<bar>x\<bar> \<noteq> \<infinity>" and y: "\<bar>y\<bar> \<noteq> \<infinity>"
   assumes f: "(f \<longlongrightarrow> x) F" and g: "(g \<longlongrightarrow> y) F"
   shows "((\<lambda>x. f x - g x) \<longlongrightarrow> x - y) F"
 proof -
   from x obtain r where x': "x = ereal r" by (cases x) auto
   with f have "((\<lambda>i. real_of_ereal (f i)) \<longlongrightarrow> r) F" by simp
   moreover
   from y obtain p where y': "y = ereal p" by (cases y) auto
   with g have "((\<lambda>i. real_of_ereal (g i)) \<longlongrightarrow> p) F" by simp
   ultimately have "((\<lambda>i. real_of_ereal (f i) - real_of_ereal (g i)) \<longlongrightarrow> r - p) F"
     by (rule tendsto_diff)
   moreover
   from eventually_finite[OF x f] eventually_finite[OF y g]
   have "eventually (\<lambda>x. f x - g x = ereal (real_of_ereal (f x) - real_of_ereal (g x))) F"
     by eventually_elim auto
   ultimately show ?thesis
     by (simp add: x' y' cong: filterlim_cong)
 qed
 
 lemma continuous_on_diff_ereal:
   "continuous_on A f \<Longrightarrow> continuous_on A g \<Longrightarrow> (\<And>x. x \<in> A \<Longrightarrow> \<bar>f x\<bar> \<noteq> \<infinity>) \<Longrightarrow> (\<And>x. x \<in> A \<Longrightarrow> \<bar>g x\<bar> \<noteq> \<infinity>) \<Longrightarrow> continuous_on A (\<lambda>z. f z - g z::ereal)"
   by (auto simp: tendsto_diff_ereal continuous_on_def)
 
 
 subsubsection \<open>Tests for code generator\<close>
 
 text \<open>A small list of simple arithmetic expressions.\<close>
 
 value "- \<infinity> :: ereal"
 value "\<bar>-\<infinity>\<bar> :: ereal"
 value "4 + 5 / 4 - ereal 2 :: ereal"
 value "ereal 3 < \<infinity>"
 value "real_of_ereal (\<infinity>::ereal) = 0"
 
 end
diff --git a/src/HOL/Library/Landau_Symbols.thy b/src/HOL/Library/Landau_Symbols.thy
--- a/src/HOL/Library/Landau_Symbols.thy
+++ b/src/HOL/Library/Landau_Symbols.thy
@@ -1,2205 +1,2188 @@
 (*
   File:   Landau_Symbols_Definition.thy
   Author: Manuel Eberl <eberlm@in.tum.de>
 
-  Landau symbols for reasoning about the asymptotic growth of functions. 
+  Landau symbols for reasoning about the asymptotic growth of functions.
 *)
 section \<open>Definition of Landau symbols\<close>
 
 theory Landau_Symbols
-imports 
+imports
   Complex_Main
 begin
 
 lemma eventually_subst':
   "eventually (\<lambda>x. f x = g x) F \<Longrightarrow> eventually (\<lambda>x. P x (f x)) F = eventually (\<lambda>x. P x (g x)) F"
   by (rule eventually_subst, erule eventually_rev_mp) simp
 
 
 subsection \<open>Definition of Landau symbols\<close>
 
 text \<open>
-  Our Landau symbols are sign-oblivious, i.e. any function always has the same growth 
-  as its absolute. This has the advantage of making some cancelling rules for sums nicer, but 
+  Our Landau symbols are sign-oblivious, i.e. any function always has the same growth
+  as its absolute. This has the advantage of making some cancelling rules for sums nicer, but
   introduces some problems in other places. Nevertheless, we found this definition more convenient
   to work with.
 \<close>
 
-definition bigo :: "'a filter \<Rightarrow> ('a \<Rightarrow> ('b :: real_normed_field)) \<Rightarrow> ('a \<Rightarrow> 'b) set" 
+definition bigo :: "'a filter \<Rightarrow> ('a \<Rightarrow> ('b :: real_normed_field)) \<Rightarrow> ('a \<Rightarrow> 'b) set"
     (\<open>(1O[_]'(_'))\<close>)
-  where "bigo F g = {f. (\<exists>c>0. eventually (\<lambda>x. norm (f x) \<le> c * norm (g x)) F)}"  
+  where "bigo F g = {f. (\<exists>c>0. eventually (\<lambda>x. norm (f x) \<le> c * norm (g x)) F)}"
 
-definition smallo :: "'a filter \<Rightarrow> ('a \<Rightarrow> ('b :: real_normed_field)) \<Rightarrow> ('a \<Rightarrow> 'b) set" 
+definition smallo :: "'a filter \<Rightarrow> ('a \<Rightarrow> ('b :: real_normed_field)) \<Rightarrow> ('a \<Rightarrow> 'b) set"
     (\<open>(1o[_]'(_'))\<close>)
   where "smallo F g = {f. (\<forall>c>0. eventually (\<lambda>x. norm (f x) \<le> c * norm (g x)) F)}"
 
-definition bigomega :: "'a filter \<Rightarrow> ('a \<Rightarrow> ('b :: real_normed_field)) \<Rightarrow> ('a \<Rightarrow> 'b) set" 
+definition bigomega :: "'a filter \<Rightarrow> ('a \<Rightarrow> ('b :: real_normed_field)) \<Rightarrow> ('a \<Rightarrow> 'b) set"
     (\<open>(1\<Omega>[_]'(_'))\<close>)
-  where "bigomega F g = {f. (\<exists>c>0. eventually (\<lambda>x. norm (f x) \<ge> c * norm (g x)) F)}"  
+  where "bigomega F g = {f. (\<exists>c>0. eventually (\<lambda>x. norm (f x) \<ge> c * norm (g x)) F)}"
 
-definition smallomega :: "'a filter \<Rightarrow> ('a \<Rightarrow> ('b :: real_normed_field)) \<Rightarrow> ('a \<Rightarrow> 'b) set" 
+definition smallomega :: "'a filter \<Rightarrow> ('a \<Rightarrow> ('b :: real_normed_field)) \<Rightarrow> ('a \<Rightarrow> 'b) set"
     (\<open>(1\<omega>[_]'(_'))\<close>)
   where "smallomega F g = {f. (\<forall>c>0. eventually (\<lambda>x. norm (f x) \<ge> c * norm (g x)) F)}"
 
-definition bigtheta :: "'a filter \<Rightarrow> ('a \<Rightarrow> ('b :: real_normed_field)) \<Rightarrow> ('a \<Rightarrow> 'b) set" 
+definition bigtheta :: "'a filter \<Rightarrow> ('a \<Rightarrow> ('b :: real_normed_field)) \<Rightarrow> ('a \<Rightarrow> 'b) set"
     (\<open>(1\<Theta>[_]'(_'))\<close>)
   where "bigtheta F g = bigo F g \<inter> bigomega F g"
 
 abbreviation bigo_at_top (\<open>(2O'(_'))\<close>) where
-  "O(g) \<equiv> bigo at_top g"    
+  "O(g) \<equiv> bigo at_top g"
 
 abbreviation smallo_at_top (\<open>(2o'(_'))\<close>) where
   "o(g) \<equiv> smallo at_top g"
 
 abbreviation bigomega_at_top (\<open>(2\<Omega>'(_'))\<close>) where
   "\<Omega>(g) \<equiv> bigomega at_top g"
 
 abbreviation smallomega_at_top (\<open>(2\<omega>'(_'))\<close>) where
   "\<omega>(g) \<equiv> smallomega at_top g"
 
 abbreviation bigtheta_at_top (\<open>(2\<Theta>'(_'))\<close>) where
   "\<Theta>(g) \<equiv> bigtheta at_top g"
-    
+
 
 text \<open>The following is a set of properties that all Landau symbols satisfy.\<close>
 
 named_theorems landau_divide_simps
 
 locale landau_symbol =
   fixes L  :: "'a filter \<Rightarrow> ('a \<Rightarrow> ('b :: real_normed_field)) \<Rightarrow> ('a \<Rightarrow> 'b) set"
   and   L'  :: "'c filter \<Rightarrow> ('c \<Rightarrow> ('b :: real_normed_field)) \<Rightarrow> ('c \<Rightarrow> 'b) set"
   and   Lr  :: "'a filter \<Rightarrow> ('a \<Rightarrow> real) \<Rightarrow> ('a \<Rightarrow> real) set"
   assumes bot': "L bot f = UNIV"
   assumes filter_mono': "F1 \<le> F2 \<Longrightarrow> L F2 f \<subseteq> L F1 f"
-  assumes in_filtermap_iff: 
+  assumes in_filtermap_iff:
     "f' \<in> L (filtermap h' F') g' \<longleftrightarrow> (\<lambda>x. f' (h' x)) \<in> L' F' (\<lambda>x. g' (h' x))"
-  assumes filtercomap: 
+  assumes filtercomap:
     "f' \<in> L F'' g' \<Longrightarrow> (\<lambda>x. f' (h' x)) \<in> L' (filtercomap h' F'') (\<lambda>x. g' (h' x))"
   assumes sup: "f \<in> L F1 g \<Longrightarrow> f \<in> L F2 g \<Longrightarrow> f \<in> L (sup F1 F2) g"
   assumes in_cong: "eventually (\<lambda>x. f x = g x) F \<Longrightarrow> f \<in> L F (h) \<longleftrightarrow> g \<in> L F (h)"
   assumes cong: "eventually (\<lambda>x. f x = g x) F \<Longrightarrow> L F (f) = L F (g)"
   assumes cong_bigtheta: "f \<in> \<Theta>[F](g) \<Longrightarrow> L F (f) = L F (g)"
   assumes in_cong_bigtheta: "f \<in> \<Theta>[F](g) \<Longrightarrow> f \<in> L F (h) \<longleftrightarrow> g \<in> L F (h)"
   assumes cmult [simp]: "c \<noteq> 0 \<Longrightarrow> L F (\<lambda>x. c * f x) = L F (f)"
   assumes cmult_in_iff [simp]: "c \<noteq> 0 \<Longrightarrow> (\<lambda>x. c * f x) \<in> L F (g) \<longleftrightarrow> f \<in> L F (g)"
   assumes mult_left [simp]: "f \<in> L F (g) \<Longrightarrow> (\<lambda>x. h x * f x) \<in> L F (\<lambda>x. h x * g x)"
-  assumes inverse: "eventually (\<lambda>x. f x \<noteq> 0) F \<Longrightarrow> eventually (\<lambda>x. g x \<noteq> 0) F \<Longrightarrow> 
+  assumes inverse: "eventually (\<lambda>x. f x \<noteq> 0) F \<Longrightarrow> eventually (\<lambda>x. g x \<noteq> 0) F \<Longrightarrow>
                         f \<in> L F (g) \<Longrightarrow> (\<lambda>x. inverse (g x)) \<in> L F (\<lambda>x. inverse (f x))"
   assumes subsetI: "f \<in> L F (g) \<Longrightarrow> L F (f) \<subseteq> L F (g)"
   assumes plus_subset1: "f \<in> o[F](g) \<Longrightarrow> L F (g) \<subseteq> L F (\<lambda>x. f x + g x)"
   assumes trans: "f \<in> L F (g) \<Longrightarrow> g \<in> L F (h) \<Longrightarrow> f \<in> L F (h)"
   assumes compose: "f \<in> L F (g) \<Longrightarrow> filterlim h' F G \<Longrightarrow> (\<lambda>x. f (h' x)) \<in> L' G (\<lambda>x. g (h' x))"
   assumes norm_iff [simp]: "(\<lambda>x. norm (f x)) \<in> Lr F (\<lambda>x. norm (g x)) \<longleftrightarrow> f \<in> L F (g)"
   assumes abs [simp]: "Lr Fr (\<lambda>x. \<bar>fr x\<bar>) = Lr Fr fr"
   assumes abs_in_iff [simp]: "(\<lambda>x. \<bar>fr x\<bar>) \<in> Lr Fr gr \<longleftrightarrow> fr \<in> Lr Fr gr"
 begin
 
 lemma bot [simp]: "f \<in> L bot g" by (simp add: bot')
-  
+
 lemma filter_mono: "F1 \<le> F2 \<Longrightarrow> f \<in> L F2 g \<Longrightarrow> f \<in> L F1 g"
   using filter_mono'[of F1 F2] by blast
 
-lemma cong_ex: 
+lemma cong_ex:
   "eventually (\<lambda>x. f1 x = f2 x) F \<Longrightarrow> eventually (\<lambda>x. g1 x = g2 x) F \<Longrightarrow>
-     f1 \<in> L F (g1) \<longleftrightarrow> f2 \<in> L F (g2)" 
+     f1 \<in> L F (g1) \<longleftrightarrow> f2 \<in> L F (g2)"
   by (subst cong, assumption, subst in_cong, assumption, rule refl)
 
-lemma cong_ex_bigtheta: 
-  "f1 \<in> \<Theta>[F](f2) \<Longrightarrow> g1 \<in> \<Theta>[F](g2) \<Longrightarrow> f1 \<in> L F (g1) \<longleftrightarrow> f2 \<in> L F (g2)" 
+lemma cong_ex_bigtheta:
+  "f1 \<in> \<Theta>[F](f2) \<Longrightarrow> g1 \<in> \<Theta>[F](g2) \<Longrightarrow> f1 \<in> L F (g1) \<longleftrightarrow> f2 \<in> L F (g2)"
   by (subst cong_bigtheta, assumption, subst in_cong_bigtheta, assumption, rule refl)
 
-lemma bigtheta_trans1: 
+lemma bigtheta_trans1:
   "f \<in> L F (g) \<Longrightarrow> g \<in> \<Theta>[F](h) \<Longrightarrow> f \<in> L F (h)"
   by (subst cong_bigtheta[symmetric])
 
-lemma bigtheta_trans2: 
+lemma bigtheta_trans2:
   "f \<in> \<Theta>[F](g) \<Longrightarrow> g \<in> L F (h) \<Longrightarrow> f \<in> L F (h)"
   by (subst in_cong_bigtheta)
-   
+
 lemma cmult' [simp]: "c \<noteq> 0 \<Longrightarrow> L F (\<lambda>x. f x * c) = L F (f)"
   by (subst mult.commute) (rule cmult)
 
 lemma cmult_in_iff' [simp]: "c \<noteq> 0 \<Longrightarrow> (\<lambda>x. f x * c) \<in> L F (g) \<longleftrightarrow> f \<in> L F (g)"
   by (subst mult.commute) (rule cmult_in_iff)
 
 lemma cdiv [simp]: "c \<noteq> 0 \<Longrightarrow> L F (\<lambda>x. f x / c) = L F (f)"
   using cmult'[of "inverse c" F f] by (simp add: field_simps)
 
 lemma cdiv_in_iff' [simp]: "c \<noteq> 0 \<Longrightarrow> (\<lambda>x. f x / c) \<in> L F (g) \<longleftrightarrow> f \<in> L F (g)"
   using cmult_in_iff'[of "inverse c" f] by (simp add: field_simps)
-  
+
 lemma uminus [simp]: "L F (\<lambda>x. -g x) = L F (g)" using cmult[of "-1"] by simp
 
 lemma uminus_in_iff [simp]: "(\<lambda>x. -f x) \<in> L F (g) \<longleftrightarrow> f \<in> L F (g)"
   using cmult_in_iff[of "-1"] by simp
 
 lemma const: "c \<noteq> 0 \<Longrightarrow> L F (\<lambda>_. c) = L F (\<lambda>_. 1)"
   by (subst (2) cmult[symmetric]) simp_all
 
 (* Simplifier loops without the NO_MATCH *)
 lemma const' [simp]: "NO_MATCH 1 c \<Longrightarrow> c \<noteq> 0 \<Longrightarrow> L F (\<lambda>_. c) = L F (\<lambda>_. 1)"
   by (rule const)
 
 lemma const_in_iff: "c \<noteq> 0 \<Longrightarrow> (\<lambda>_. c) \<in> L F (f) \<longleftrightarrow> (\<lambda>_. 1) \<in> L F (f)"
   using cmult_in_iff'[of c "\<lambda>_. 1"] by simp
 
 lemma const_in_iff' [simp]: "NO_MATCH 1 c \<Longrightarrow> c \<noteq> 0 \<Longrightarrow> (\<lambda>_. c) \<in> L F (f) \<longleftrightarrow> (\<lambda>_. 1) \<in> L F (f)"
   by (rule const_in_iff)
 
 lemma plus_subset2: "g \<in> o[F](f) \<Longrightarrow> L F (f) \<subseteq> L F (\<lambda>x. f x + g x)"
   by (subst add.commute) (rule plus_subset1)
 
 lemma mult_right [simp]: "f \<in> L F (g) \<Longrightarrow> (\<lambda>x. f x * h x) \<in> L F (\<lambda>x. g x * h x)"
   using mult_left by (simp add: mult.commute)
 
 lemma mult: "f1 \<in> L F (g1) \<Longrightarrow> f2 \<in> L F (g2) \<Longrightarrow> (\<lambda>x. f1 x * f2 x) \<in> L F (\<lambda>x. g1 x * g2 x)"
   by (rule trans, erule mult_left, erule mult_right)
 
 lemma inverse_cancel:
   assumes "eventually (\<lambda>x. f x \<noteq> 0) F"
   assumes "eventually (\<lambda>x. g x \<noteq> 0) F"
   shows   "(\<lambda>x. inverse (f x)) \<in> L F (\<lambda>x. inverse (g x)) \<longleftrightarrow> g \<in> L F (f)"
 proof
   assume "(\<lambda>x. inverse (f x)) \<in> L F (\<lambda>x. inverse (g x))"
   from inverse[OF _ _ this] assms show "g \<in> L F (f)" by simp
 qed (intro inverse assms)
 
 lemma divide_right:
   assumes "eventually (\<lambda>x. h x \<noteq> 0) F"
   assumes "f \<in> L F (g)"
   shows   "(\<lambda>x. f x / h x) \<in> L F (\<lambda>x. g x / h x)"
   by (subst (1 2) divide_inverse) (intro mult_right inverse assms)
 
 lemma divide_right_iff:
   assumes "eventually (\<lambda>x. h x \<noteq> 0) F"
   shows   "(\<lambda>x. f x / h x) \<in> L F (\<lambda>x. g x / h x) \<longleftrightarrow> f \<in> L F (g)"
 proof
   assume "(\<lambda>x. f x / h x) \<in> L F (\<lambda>x. g x / h x)"
   from mult_right[OF this, of h] assms show "f \<in> L F (g)"
     by (subst (asm) cong_ex[of _ f F _ g]) (auto elim!: eventually_mono)
 qed (simp add: divide_right assms)
 
 lemma divide_left:
   assumes "eventually (\<lambda>x. f x \<noteq> 0) F"
   assumes "eventually (\<lambda>x. g x \<noteq> 0) F"
   assumes "g \<in> L F(f)"
   shows   "(\<lambda>x. h x / f x) \<in> L F (\<lambda>x. h x / g x)"
   by (subst (1 2) divide_inverse) (intro mult_left inverse assms)
 
 lemma divide_left_iff:
   assumes "eventually (\<lambda>x. f x \<noteq> 0) F"
   assumes "eventually (\<lambda>x. g x \<noteq> 0) F"
   assumes "eventually (\<lambda>x. h x \<noteq> 0) F"
   shows   "(\<lambda>x. h x / f x) \<in> L F (\<lambda>x. h x / g x) \<longleftrightarrow> g \<in> L F (f)"
 proof
   assume A: "(\<lambda>x. h x / f x) \<in> L F (\<lambda>x. h x / g x)"
   from assms have B: "eventually (\<lambda>x. h x / f x / h x = inverse (f x)) F"
     by eventually_elim (simp add: divide_inverse)
   from assms have C: "eventually (\<lambda>x. h x / g x / h x = inverse (g x)) F"
     by eventually_elim (simp add: divide_inverse)
   from divide_right[OF assms(3) A] assms show "g \<in> L F (f)"
     by (subst (asm) cong_ex[OF B C]) (simp add: inverse_cancel)
 qed (simp add: divide_left assms)
 
 lemma divide:
   assumes "eventually (\<lambda>x. g1 x \<noteq> 0) F"
   assumes "eventually (\<lambda>x. g2 x \<noteq> 0) F"
   assumes "f1 \<in> L F (f2)" "g2 \<in> L F (g1)"
   shows   "(\<lambda>x. f1 x / g1 x) \<in> L F (\<lambda>x. f2 x / g2 x)"
   by (subst (1 2) divide_inverse) (intro mult inverse assms)
-  
+
 lemma divide_eq1:
   assumes "eventually (\<lambda>x. h x \<noteq> 0) F"
   shows   "f \<in> L F (\<lambda>x. g x / h x) \<longleftrightarrow> (\<lambda>x. f x * h x) \<in> L F (g)"
 proof-
   have "f \<in> L F (\<lambda>x. g x / h x) \<longleftrightarrow> (\<lambda>x. f x * h x / h x) \<in> L F (\<lambda>x. g x / h x)"
     using assms by (intro in_cong) (auto elim: eventually_mono)
   thus ?thesis by (simp only: divide_right_iff assms)
 qed
 
 lemma divide_eq2:
   assumes "eventually (\<lambda>x. h x \<noteq> 0) F"
   shows   "(\<lambda>x. f x / h x) \<in> L F (\<lambda>x. g x) \<longleftrightarrow> f \<in> L F (\<lambda>x. g x * h x)"
 proof-
   have "L F (\<lambda>x. g x) = L F (\<lambda>x. g x * h x / h x)"
     using assms by (intro cong) (auto elim: eventually_mono)
   thus ?thesis by (simp only: divide_right_iff assms)
 qed
 
 lemma inverse_eq1:
   assumes "eventually (\<lambda>x. g x \<noteq> 0) F"
   shows   "f \<in> L F (\<lambda>x. inverse (g x)) \<longleftrightarrow> (\<lambda>x. f x * g x) \<in> L F (\<lambda>_. 1)"
   using divide_eq1[of g F f "\<lambda>_. 1"] by (simp add: divide_inverse assms)
 
 lemma inverse_eq2:
   assumes "eventually (\<lambda>x. f x \<noteq> 0) F"
   shows   "(\<lambda>x. inverse (f x)) \<in> L F (g) \<longleftrightarrow> (\<lambda>x. 1) \<in> L F (\<lambda>x. f x * g x)"
   using divide_eq2[of f F "\<lambda>_. 1" g] by (simp add: divide_inverse assms mult_ac)
 
 lemma inverse_flip:
   assumes "eventually (\<lambda>x. g x \<noteq> 0) F"
   assumes "eventually (\<lambda>x. h x \<noteq> 0) F"
   assumes "(\<lambda>x. inverse (g x)) \<in> L F (h)"
   shows   "(\<lambda>x. inverse (h x)) \<in> L F (g)"
 using assms by (simp add: divide_eq1 divide_eq2 inverse_eq_divide mult.commute)
 
 lemma lift_trans:
   assumes "f \<in> L F (g)"
   assumes "(\<lambda>x. t x (g x)) \<in> L F (h)"
   assumes "\<And>f g. f \<in> L F (g) \<Longrightarrow> (\<lambda>x. t x (f x)) \<in> L F (\<lambda>x. t x (g x))"
   shows   "(\<lambda>x. t x (f x)) \<in> L F (h)"
   by (rule trans[OF assms(3)[OF assms(1)] assms(2)])
 
 lemma lift_trans':
   assumes "f \<in> L F (\<lambda>x. t x (g x))"
   assumes "g \<in> L F (h)"
   assumes "\<And>g h. g \<in> L F (h) \<Longrightarrow> (\<lambda>x. t x (g x)) \<in> L F (\<lambda>x. t x (h x))"
   shows   "f \<in> L F (\<lambda>x. t x (h x))"
   by (rule trans[OF assms(1) assms(3)[OF assms(2)]])
 
 lemma lift_trans_bigtheta:
   assumes "f \<in> L F (g)"
   assumes "(\<lambda>x. t x (g x)) \<in> \<Theta>[F](h)"
   assumes "\<And>f g. f \<in> L F (g) \<Longrightarrow> (\<lambda>x. t x (f x)) \<in> L F (\<lambda>x. t x (g x))"
   shows   "(\<lambda>x. t x (f x)) \<in> L F (h)"
   using cong_bigtheta[OF assms(2)] assms(3)[OF assms(1)] by simp
 
 lemma lift_trans_bigtheta':
   assumes "f \<in> L F (\<lambda>x. t x (g x))"
   assumes "g \<in> \<Theta>[F](h)"
   assumes "\<And>g h. g \<in> \<Theta>[F](h) \<Longrightarrow> (\<lambda>x. t x (g x)) \<in> \<Theta>[F](\<lambda>x. t x (h x))"
   shows   "f \<in> L F (\<lambda>x. t x (h x))"
   using cong_bigtheta[OF assms(3)[OF assms(2)]] assms(1)  by simp
 
 lemma (in landau_symbol) mult_in_1:
   assumes "f \<in> L F (\<lambda>_. 1)" "g \<in> L F (\<lambda>_. 1)"
   shows   "(\<lambda>x. f x * g x) \<in> L F (\<lambda>_. 1)"
   using mult[OF assms] by simp
 
 lemma (in landau_symbol) of_real_cancel:
   "(\<lambda>x. of_real (f x)) \<in> L F (\<lambda>x. of_real (g x)) \<Longrightarrow> f \<in> Lr F g"
   by (subst (asm) norm_iff [symmetric], subst (asm) (1 2) norm_of_real) simp_all
 
 lemma (in landau_symbol) of_real_iff:
   "(\<lambda>x. of_real (f x)) \<in> L F (\<lambda>x. of_real (g x)) \<longleftrightarrow> f \<in> Lr F g"
   by (subst norm_iff [symmetric], subst (1 2) norm_of_real) simp_all
 
-lemmas [landau_divide_simps] = 
+lemmas [landau_divide_simps] =
   inverse_cancel divide_left_iff divide_eq1 divide_eq2 inverse_eq1 inverse_eq2
 
 end
 
 
 text \<open>
-  The symbols $O$ and $o$ and $\Omega$ and $\omega$ are dual, so for many rules, replacing $O$ with 
+  The symbols $O$ and $o$ and $\Omega$ and $\omega$ are dual, so for many rules, replacing $O$ with
   $\Omega$, $o$ with $\omega$, and $\leq$ with $\geq$ in a theorem yields another valid theorem.
   The following locale captures this fact.
 \<close>
 
-locale landau_pair = 
+locale landau_pair =
   fixes L l :: "'a filter \<Rightarrow> ('a \<Rightarrow> ('b :: real_normed_field)) \<Rightarrow> ('a \<Rightarrow> 'b) set"
   fixes L' l' :: "'c filter \<Rightarrow> ('c \<Rightarrow> ('b :: real_normed_field)) \<Rightarrow> ('c \<Rightarrow> 'b) set"
   fixes Lr lr :: "'a filter \<Rightarrow> ('a \<Rightarrow> real) \<Rightarrow> ('a \<Rightarrow> real) set"
   and   R :: "real \<Rightarrow> real \<Rightarrow> bool"
   assumes L_def: "L F g = {f. \<exists>c>0. eventually (\<lambda>x. R (norm (f x)) (c * norm (g x))) F}"
   and     l_def: "l F g = {f. \<forall>c>0. eventually (\<lambda>x. R (norm (f x)) (c * norm (g x))) F}"
   and     L'_def: "L' F' g' = {f. \<exists>c>0. eventually (\<lambda>x. R (norm (f x)) (c * norm (g' x))) F'}"
   and     l'_def: "l' F' g' = {f. \<forall>c>0. eventually (\<lambda>x. R (norm (f x)) (c * norm (g' x))) F'}"
   and     Lr_def: "Lr F'' g'' = {f. \<exists>c>0. eventually (\<lambda>x. R (norm (f x)) (c * norm (g'' x))) F''}"
   and     lr_def: "lr F'' g'' = {f. \<forall>c>0. eventually (\<lambda>x. R (norm (f x)) (c * norm (g'' x))) F''}"
   and     R:     "R = (\<le>) \<or> R = (\<ge>)"
 
-interpretation landau_o: 
+interpretation landau_o:
     landau_pair bigo smallo bigo smallo bigo smallo "(\<le>)"
   by unfold_locales (auto simp: bigo_def smallo_def intro!: ext)
 
-interpretation landau_omega: 
+interpretation landau_omega:
     landau_pair bigomega smallomega bigomega smallomega bigomega smallomega "(\<ge>)"
   by unfold_locales (auto simp: bigomega_def smallomega_def intro!: ext)
 
 
 context landau_pair
 begin
 
 lemmas R_E = disjE [OF R, case_names le ge]
 
 lemma bigI:
   "c > 0 \<Longrightarrow> eventually (\<lambda>x. R (norm (f x)) (c * norm (g x))) F \<Longrightarrow> f \<in> L F (g)"
   unfolding L_def by blast
 
 lemma bigE:
   assumes "f \<in> L F (g)"
   obtains c where "c > 0" "eventually (\<lambda>x. R (norm (f x)) (c * (norm (g x)))) F"
   using assms unfolding L_def by blast
 
 lemma smallI:
   "(\<And>c. c > 0 \<Longrightarrow> eventually (\<lambda>x. R (norm (f x)) (c * (norm (g x)))) F) \<Longrightarrow> f \<in> l F (g)"
   unfolding l_def by blast
 
 lemma smallD:
   "f \<in> l F (g) \<Longrightarrow> c > 0 \<Longrightarrow> eventually (\<lambda>x. R (norm (f x)) (c * (norm (g x)))) F"
   unfolding l_def by blast
-    
+
 lemma bigE_nonneg_real:
   assumes "f \<in> Lr F (g)" "eventually (\<lambda>x. f x \<ge> 0) F"
   obtains c where "c > 0" "eventually (\<lambda>x. R (f x) (c * \<bar>g x\<bar>)) F"
 proof-
   from assms(1) obtain c where c: "c > 0" "eventually (\<lambda>x. R (norm (f x)) (c * norm (g x))) F"
     by (auto simp: Lr_def)
   from c(2) assms(2) have "eventually (\<lambda>x. R (f x) (c * \<bar>g x\<bar>)) F"
     by eventually_elim simp
   from c(1) and this show ?thesis by (rule that)
 qed
 
 lemma smallD_nonneg_real:
   assumes "f \<in> lr F (g)" "eventually (\<lambda>x. f x \<ge> 0) F" "c > 0"
   shows   "eventually (\<lambda>x. R (f x) (c * \<bar>g x\<bar>)) F"
   using assms by (auto simp: lr_def dest!: spec[of _ c] elim: eventually_elim2)
 
 lemma small_imp_big: "f \<in> l F (g) \<Longrightarrow> f \<in> L F (g)"
   by (rule bigI[OF _ smallD, of 1]) simp_all
-  
+
 lemma small_subset_big: "l F (g) \<subseteq> L F (g)"
   using small_imp_big by blast
 
 lemma R_refl [simp]: "R x x" using R by auto
 
 lemma R_linear: "\<not>R x y \<Longrightarrow> R y x"
   using R by auto
 
 lemma R_trans [trans]: "R a b \<Longrightarrow> R b c \<Longrightarrow> R a c"
   using R by auto
 
 lemma R_mult_left_mono: "R a b \<Longrightarrow> c \<ge> 0 \<Longrightarrow> R (c*a) (c*b)"
   using R by (auto simp: mult_left_mono)
 
 lemma R_mult_right_mono: "R a b \<Longrightarrow> c \<ge> 0 \<Longrightarrow> R (a*c) (b*c)"
   using R by (auto simp: mult_right_mono)
 
 lemma big_trans:
   assumes "f \<in> L F (g)" "g \<in> L F (h)"
   shows   "f \<in> L F (h)"
 proof-
-  from assms(1) guess c by (elim bigE) note c = this
-  from assms(2) guess d by (elim bigE) note d = this
-  from c(2) d(2) have "eventually (\<lambda>x. R (norm (f x)) (c * d * (norm (h x)))) F"
+  from assms obtain c d where *: "0 < c" "0 < d"
+    and **: "\<forall>\<^sub>F x in F. R (norm (f x)) (c * norm (g x))"
+            "\<forall>\<^sub>F x in F. R (norm (g x)) (d * norm (h x))"
+    by (elim bigE)
+  from ** have "eventually (\<lambda>x. R (norm (f x)) (c * d * (norm (h x)))) F"
   proof eventually_elim
     fix x assume "R (norm (f x)) (c * (norm (g x)))"
     also assume "R (norm (g x)) (d * (norm (h x)))"
-    with c(1) have "R (c * (norm (g x))) (c * (d * (norm (h x))))"
+    with \<open>0 < c\<close> have "R (c * (norm (g x))) (c * (d * (norm (h x))))"
       by (intro R_mult_left_mono) simp_all
-    finally show "R (norm (f x)) (c * d * (norm (h x)))" by (simp add: algebra_simps)
+    finally show "R (norm (f x)) (c * d * (norm (h x)))"
+      by (simp add: algebra_simps)
   qed
-  with c(1) d(1) show ?thesis by (intro bigI[of "c*d"]) simp_all
+  with * show ?thesis by (intro bigI[of "c*d"]) simp_all
 qed
 
 lemma big_small_trans:
   assumes "f \<in> L F (g)" "g \<in> l F (h)"
   shows   "f \<in> l F (h)"
 proof (rule smallI)
   fix c :: real assume c: "c > 0"
-  from assms(1) guess d by (elim bigE) note d = this
-  note d(2)
-  moreover from c d assms(2) 
-    have "eventually (\<lambda>x. R (norm (g x)) (c * inverse d * norm (h x))) F" 
+  from assms(1) obtain d where d: "d > 0" and *: "\<forall>\<^sub>F x in F. R (norm (f x)) (d * norm (g x))"
+    by (elim bigE)
+  from assms(2) c d have "eventually (\<lambda>x. R (norm (g x)) (c * inverse d * norm (h x))) F"
     by (intro smallD) simp_all
-  ultimately show "eventually (\<lambda>x. R (norm (f x)) (c * (norm (h x)))) F"
-    by eventually_elim (erule R_trans, insert R d(1), auto simp: field_simps)
+  with * show "eventually (\<lambda>x. R (norm (f x)) (c * (norm (h x)))) F"
+  proof eventually_elim
+    case (elim x)
+    show ?case
+      by (use elim(1) in \<open>rule R_trans\<close>) (use elim(2) R d in \<open>auto simp: field_simps\<close>)
+  qed
 qed
 
 lemma small_big_trans:
   assumes "f \<in> l F (g)" "g \<in> L F (h)"
   shows   "f \<in> l F (h)"
 proof (rule smallI)
   fix c :: real assume c: "c > 0"
-  from assms(2) guess d by (elim bigE) note d = this
-  note d(2)
-  moreover from c d assms(1) 
-    have "eventually (\<lambda>x. R (norm (f x)) (c * inverse d * norm (g x))) F"
+  from assms(2) obtain d where d: "d > 0" and *: "\<forall>\<^sub>F x in F. R (norm (g x)) (d * norm (h x))"
+    by (elim bigE)
+  from assms(1) c d have "eventually (\<lambda>x. R (norm (f x)) (c * inverse d * norm (g x))) F"
     by (intro smallD) simp_all
-  ultimately show "eventually (\<lambda>x. R (norm (f x)) (c * norm (h x))) F"
-    by eventually_elim (rotate_tac 2, erule R_trans, insert R c d(1), auto simp: field_simps)
+  with * show "eventually (\<lambda>x. R (norm (f x)) (c * norm (h x))) F"
+    by eventually_elim (rotate_tac 2, erule R_trans, insert R c d, auto simp: field_simps)
 qed
 
 lemma small_trans:
   "f \<in> l F (g) \<Longrightarrow> g \<in> l F (h) \<Longrightarrow> f \<in> l F (h)"
   by (rule big_small_trans[OF small_imp_big])
 
 lemma small_big_trans':
   "f \<in> l F (g) \<Longrightarrow> g \<in> L F (h) \<Longrightarrow> f \<in> L F (h)"
   by (rule small_imp_big[OF small_big_trans])
 
 lemma big_small_trans':
   "f \<in> L F (g) \<Longrightarrow> g \<in> l F (h) \<Longrightarrow> f \<in> L F (h)"
   by (rule small_imp_big[OF big_small_trans])
 
 lemma big_subsetI [intro]: "f \<in> L F (g) \<Longrightarrow> L F (f) \<subseteq> L F (g)"
   by (intro subsetI) (drule (1) big_trans)
 
 lemma small_subsetI [intro]: "f \<in> L F (g) \<Longrightarrow> l F (f) \<subseteq> l F (g)"
   by (intro subsetI) (drule (1) small_big_trans)
 
 lemma big_refl [simp]: "f \<in> L F (f)"
   by (rule bigI[of 1]) simp_all
 
 lemma small_refl_iff: "f \<in> l F (f) \<longleftrightarrow> eventually (\<lambda>x. f x = 0) F"
 proof (rule iffI[OF _ smallI])
   assume f: "f \<in> l F f"
   have "(1/2::real) > 0" "(2::real) > 0" by simp_all
   from smallD[OF f this(1)] smallD[OF f this(2)]
     show "eventually (\<lambda>x. f x = 0) F" by eventually_elim (insert R, auto)
 next
   fix c :: real assume "c > 0" "eventually (\<lambda>x. f x = 0) F"
   from this(2) show "eventually (\<lambda>x. R (norm (f x)) (c * norm (f x))) F"
     by eventually_elim simp_all
 qed
 
 lemma big_small_asymmetric: "f \<in> L F (g) \<Longrightarrow> g \<in> l F (f) \<Longrightarrow> eventually (\<lambda>x. f x = 0) F"
   by (drule (1) big_small_trans) (simp add: small_refl_iff)
 
 lemma small_big_asymmetric: "f \<in> l F (g) \<Longrightarrow> g \<in> L F (f) \<Longrightarrow> eventually (\<lambda>x. f x = 0) F"
   by (drule (1) small_big_trans) (simp add: small_refl_iff)
 
 lemma small_asymmetric: "f \<in> l F (g) \<Longrightarrow> g \<in> l F (f) \<Longrightarrow> eventually (\<lambda>x. f x = 0) F"
   by (drule (1) small_trans) (simp add: small_refl_iff)
 
 
 lemma plus_aux:
   assumes "f \<in> o[F](g)"
   shows "g \<in> L F (\<lambda>x. f x + g x)"
 proof (rule R_E)
-  assume [simp]: "R = (\<le>)"
+  assume R: "R = (\<le>)"
   have A: "1/2 > (0::real)" by simp
-  {
-    fix x assume "norm (f x) \<le> 1/2 * norm (g x)"
-    hence "1/2 * (norm (g x)) \<le> (norm (g x)) - (norm (f x))" by simp
+  have B: "1/2 * (norm (g x)) \<le> norm (f x + g x)"
+    if "norm (f x) \<le> 1/2 * norm (g x)" for x
+  proof -
+    from that have "1/2 * (norm (g x)) \<le> (norm (g x)) - (norm (f x))"
+      by simp
     also have "norm (g x) - norm (f x) \<le> norm (f x + g x)"
       by (subst add.commute) (rule norm_diff_ineq)
-    finally have "1/2 * (norm (g x)) \<le> norm (f x + g x)" by simp
-  } note B = this
-  
+    finally show ?thesis by simp
+  qed
   show "g \<in> L F (\<lambda>x. f x + g x)"
-    apply (rule bigI[of "2"], simp)
-    using landau_o.smallD[OF assms A] apply eventually_elim
-    using B apply (simp add: algebra_simps) 
+    apply (rule bigI[of "2"])
+     apply simp
+    apply (use landau_o.smallD[OF assms A] in eventually_elim)
+    apply (use B in \<open>simp add: R algebra_simps\<close>)
     done
 next
-  assume [simp]: "R = (\<lambda>x y. x \<ge> y)"
+  assume R: "R = (\<lambda>x y. x \<ge> y)"
   show "g \<in> L F (\<lambda>x. f x + g x)"
   proof (rule bigI[of "1/2"])
     show "eventually (\<lambda>x. R (norm (g x)) (1/2 * norm (f x + g x))) F"
       using landau_o.smallD[OF assms zero_less_one]
     proof eventually_elim
       case (elim x)
-      have "norm (f x + g x) \<le> norm (f x) + norm (g x)" by (rule norm_triangle_ineq)
+      have "norm (f x + g x) \<le> norm (f x) + norm (g x)"
+        by (rule norm_triangle_ineq)
       also note elim
-      finally show ?case by simp
+      finally show ?case by (simp add: R)
     qed
   qed simp_all
 qed
 
 end
 
 
-
 lemma bigomega_iff_bigo: "g \<in> \<Omega>[F](f) \<longleftrightarrow> f \<in> O[F](g)"
 proof
   assume "f \<in> O[F](g)"
-  then guess c by (elim landau_o.bigE)
-  thus "g \<in> \<Omega>[F](f)" by (intro landau_omega.bigI[of "inverse c"]) (simp_all add: field_simps)
+  then obtain c where "0 < c" "\<forall>\<^sub>F x in F. norm (f x) \<le> c * norm (g x)"
+    by (rule landau_o.bigE)
+  then show "g \<in> \<Omega>[F](f)"
+    by (intro landau_omega.bigI[of "inverse c"]) (simp_all add: field_simps)
 next
   assume "g \<in> \<Omega>[F](f)"
-  then guess c by (elim landau_omega.bigE)
-  thus "f \<in> O[F](g)" by (intro landau_o.bigI[of "inverse c"]) (simp_all add: field_simps)
+  then obtain c where "0 < c" "\<forall>\<^sub>F x in F. c * norm (f x) \<le> norm (g x)"
+    by (rule landau_omega.bigE)
+  then show "f \<in> O[F](g)"
+    by (intro landau_o.bigI[of "inverse c"]) (simp_all add: field_simps)
 qed
 
 lemma smallomega_iff_smallo: "g \<in> \<omega>[F](f) \<longleftrightarrow> f \<in> o[F](g)"
 proof
   assume "f \<in> o[F](g)"
   from landau_o.smallD[OF this, of "inverse c" for c]
     show "g \<in> \<omega>[F](f)" by (intro landau_omega.smallI) (simp_all add: field_simps)
 next
   assume "g \<in> \<omega>[F](f)"
   from landau_omega.smallD[OF this, of "inverse c" for c]
     show "f \<in> o[F](g)" by (intro landau_o.smallI) (simp_all add: field_simps)
 qed
 
 
 context landau_pair
 begin
 
 lemma big_mono:
   "eventually (\<lambda>x. R (norm (f x)) (norm (g x))) F \<Longrightarrow> f \<in> L F (g)"
   by (rule bigI[OF zero_less_one]) simp
 
 lemma big_mult:
   assumes "f1 \<in> L F (g1)" "f2 \<in> L F (g2)"
   shows   "(\<lambda>x. f1 x * f2 x) \<in> L F (\<lambda>x. g1 x * g2 x)"
 proof-
-  from assms(1) guess c1 by (elim bigE) note c1 = this
-  from assms(2) guess c2 by (elim bigE) note c2 = this
-  
-  from c1(1) and c2(1) have "c1 * c2 > 0" by simp
+  from assms obtain c1 c2 where *: "c1 > 0" "c2 > 0"
+    and **: "\<forall>\<^sub>F x in F. R (norm (f1 x)) (c1 * norm (g1 x))"
+            "\<forall>\<^sub>F x in F. R (norm (f2 x)) (c2 * norm (g2 x))"
+    by (elim bigE)
+  from * have "c1 * c2 > 0" by simp
   moreover have "eventually (\<lambda>x. R (norm (f1 x * f2 x)) (c1 * c2 * norm (g1 x * g2 x))) F"
-    using c1(2) c2(2)
+    using **
   proof eventually_elim
     case (elim x)
     show ?case
     proof (cases rule: R_E)
       case le
       have "norm (f1 x) * norm (f2 x) \<le> (c1 * norm (g1 x)) * (c2 * norm (g2 x))"
-        using elim le c1(1) c2(1) by (intro mult_mono mult_nonneg_nonneg) auto
+        using elim le * by (intro mult_mono mult_nonneg_nonneg) auto
       with le show ?thesis by (simp add: le norm_mult mult_ac)
     next
       case ge
       have "(c1 * norm (g1 x)) * (c2 * norm (g2 x)) \<le> norm (f1 x) * norm (f2 x)"
-        using elim ge c1(1) c2(1) by (intro mult_mono mult_nonneg_nonneg) auto
+        using elim ge * by (intro mult_mono mult_nonneg_nonneg) auto
       with ge show ?thesis by (simp_all add: norm_mult mult_ac)
     qed
   qed
   ultimately show ?thesis by (rule bigI)
 qed
 
 lemma small_big_mult:
   assumes "f1 \<in> l F (g1)" "f2 \<in> L F (g2)"
   shows   "(\<lambda>x. f1 x * f2 x) \<in> l F (\<lambda>x. g1 x * g2 x)"
 proof (rule smallI)
   fix c1 :: real assume c1: "c1 > 0"
-  from assms(2) guess c2 by (elim bigE) note c2 = this
-  with c1 assms(1) have "eventually (\<lambda>x. R (norm (f1 x)) (c1 * inverse c2 * norm (g1 x))) F"
+  from assms(2) obtain c2 where c2: "c2 > 0"
+    and *: "\<forall>\<^sub>F x in F. R (norm (f2 x)) (c2 * norm (g2 x))" by (elim bigE)
+  from assms(1) c1 c2 have "eventually (\<lambda>x. R (norm (f1 x)) (c1 * inverse c2 * norm (g1 x))) F"
     by (auto intro!: smallD)
-  thus "eventually (\<lambda>x. R (norm (f1 x * f2 x)) (c1 * norm (g1 x * g2 x))) F" using c2(2)
+  with * show "eventually (\<lambda>x. R (norm (f1 x * f2 x)) (c1 * norm (g1 x * g2 x))) F"
   proof eventually_elim
     case (elim x)
     show ?case
     proof (cases rule: R_E)
       case le
       have "norm (f1 x) * norm (f2 x) \<le> (c1 * inverse c2 * norm (g1 x)) * (c2 * norm (g2 x))"
-        using elim le c1(1) c2(1) by (intro mult_mono mult_nonneg_nonneg) auto
-      with le c2(1) show ?thesis by (simp add: le norm_mult field_simps)
+        using elim le c1 c2 by (intro mult_mono mult_nonneg_nonneg) auto
+      with le c2 show ?thesis by (simp add: le norm_mult field_simps)
     next
       case ge
       have "norm (f1 x) * norm (f2 x) \<ge> (c1 * inverse c2 * norm (g1 x)) * (c2 * norm (g2 x))"
-        using elim ge c1(1) c2(1) by (intro mult_mono mult_nonneg_nonneg) auto
-      with ge c2(1) show ?thesis by (simp add: ge norm_mult field_simps)
+        using elim ge c1 c2 by (intro mult_mono mult_nonneg_nonneg) auto
+      with ge c2 show ?thesis by (simp add: ge norm_mult field_simps)
     qed
   qed
 qed
 
-lemma big_small_mult: 
+lemma big_small_mult:
   "f1 \<in> L F (g1) \<Longrightarrow> f2 \<in> l F (g2) \<Longrightarrow> (\<lambda>x. f1 x * f2 x) \<in> l F (\<lambda>x. g1 x * g2 x)"
   by (subst (1 2) mult.commute) (rule small_big_mult)
 
 lemma small_mult: "f1 \<in> l F (g1) \<Longrightarrow> f2 \<in> l F (g2) \<Longrightarrow> (\<lambda>x. f1 x * f2 x) \<in> l F (\<lambda>x. g1 x * g2 x)"
   by (rule small_big_mult, assumption, rule small_imp_big)
 
 lemmas mult = big_mult small_big_mult big_small_mult small_mult
 
 
 sublocale big: landau_symbol L L' Lr
 proof
   have L: "L = bigo \<or> L = bigomega"
     by (rule R_E) (auto simp: bigo_def L_def bigomega_def fun_eq_iff)
-  {
-    fix c :: 'b and F and f :: "'a \<Rightarrow> 'b" assume "c \<noteq> 0"
-    hence "(\<lambda>x. c * f x) \<in> L F f" by (intro bigI[of "norm c"]) (simp_all add: norm_mult)
-  } note A = this
-  {
-    fix c :: 'b and F and f :: "'a \<Rightarrow> 'b" assume "c \<noteq> 0"
-    from \<open>c \<noteq> 0\<close> and A[of c f] and A[of "inverse c" "\<lambda>x. c * f x"] 
-      show "L F (\<lambda>x. c * f x) = L F f" by (intro equalityI big_subsetI) (simp_all add: field_simps)
-  }
-  {
-    fix c :: 'b and F and f g :: "'a \<Rightarrow> 'b" assume "c \<noteq> 0"
+  have A: "(\<lambda>x. c * f x) \<in> L F f" if "c \<noteq> 0" for c :: 'b and F and f :: "'a \<Rightarrow> 'b"
+    using that by (intro bigI[of "norm c"]) (simp_all add: norm_mult)
+  show "L F (\<lambda>x. c * f x) = L F f" if "c \<noteq> 0" for c :: 'b and F and f :: "'a \<Rightarrow> 'b"
+    using \<open>c \<noteq> 0\<close> and A[of c f] and A[of "inverse c" "\<lambda>x. c * f x"]
+    by (intro equalityI big_subsetI) (simp_all add: field_simps)
+  show "((\<lambda>x. c * f x) \<in> L F g) = (f \<in> L F g)" if "c \<noteq> 0"
+    for c :: 'b and F and f g :: "'a \<Rightarrow> 'b"
+  proof -
     from \<open>c \<noteq> 0\<close> and A[of c f] and A[of "inverse c" "\<lambda>x. c * f x"]
-      have "(\<lambda>x. c * f x) \<in> L F f" "f \<in> L F (\<lambda>x. c * f x)" by (simp_all add: field_simps)
-    thus "((\<lambda>x. c * f x) \<in> L F g) = (f \<in> L F g)" by (intro iffI) (erule (1) big_trans)+
-  }
-  {
-    fix f g :: "'a \<Rightarrow> 'b" and F assume A: "f \<in> L F (g)"
-    assume B: "eventually (\<lambda>x. f x \<noteq> 0) F" "eventually (\<lambda>x. g x \<noteq> 0) F"
-    from A guess c by (elim bigE) note c = this
-    from c(2) B have "eventually (\<lambda>x. R (norm (inverse (g x))) (c * norm (inverse (f x)))) F"
-      by eventually_elim (rule R_E, insert c(1), simp_all add: field_simps norm_inverse norm_divide)
-    with c(1) show "(\<lambda>x. inverse (g x)) \<in> L F (\<lambda>x. inverse (f x))" by (rule bigI)
-  }
-  {
-    fix f g :: "'a \<Rightarrow> 'b" and F assume "f \<in> o[F](g)"
-    with plus_aux show "L F g \<subseteq> L F (\<lambda>x. f x + g x)" by (blast intro!: big_subsetI) 
-  }
-  {
-    fix f g :: "'a \<Rightarrow> 'b" and F assume A: "eventually (\<lambda>x. f x = g x) F"
-    show "L F (f) = L F (g)" unfolding L_def
-      by (subst eventually_subst'[OF A]) (rule refl)
-  }
-  {
-    fix f g h :: "'a \<Rightarrow> 'b" and F assume A: "eventually (\<lambda>x. f x = g x) F"
-    show "f \<in> L F (h) \<longleftrightarrow> g \<in> L F (h)" unfolding L_def mem_Collect_eq
-      by (subst (1) eventually_subst'[OF A]) (rule refl)
-  }
-  {
-    fix f g :: "'a \<Rightarrow> 'b" and F assume "f \<in> L F g" thus "L F f \<subseteq> L F g" by (rule big_subsetI)
-  }
-  {
-    fix f g :: "'a \<Rightarrow> 'b" and F assume A: "f \<in> \<Theta>[F](g)"
-    with A L show "L F (f) = L F (g)" unfolding bigtheta_def
-      by (intro equalityI big_subsetI) (auto simp: bigomega_iff_bigo)
-    fix h:: "'a \<Rightarrow> 'b"
-    show "f \<in> L F (h) \<longleftrightarrow> g \<in> L F (h)" by (rule disjE[OF L]) 
-      (insert A, auto simp: bigtheta_def bigomega_iff_bigo intro: landau_o.big_trans)
-  }
-  {
-    fix f g h :: "'a \<Rightarrow> 'b" and F assume "f \<in> L F g"
-    thus "(\<lambda>x. h x * f x) \<in> L F (\<lambda>x. h x * g x)" by (intro big_mult) simp
-  }
-  {
-    fix f g h :: "'a \<Rightarrow> 'b" and F assume "f \<in> L F g" "g \<in> L F h"
-    thus "f \<in> L F (h)" by (rule big_trans)
-  }
-  {
-    fix f g :: "'a \<Rightarrow> 'b" and h :: "'c \<Rightarrow> 'a" and F G
-    assume "f \<in> L F g" and "filterlim h F G"
-    thus "(\<lambda>x. f (h x)) \<in> L' G (\<lambda>x. g (h x))" by (auto simp: L_def L'_def filterlim_iff)
-  }
-  {
-    fix f g :: "'a \<Rightarrow> 'b" and F G :: "'a filter"
-    assume "f \<in> L F g" "f \<in> L G g"
-    from this [THEN bigE] guess c1 c2 . note c12 = this
+    have "(\<lambda>x. c * f x) \<in> L F f" "f \<in> L F (\<lambda>x. c * f x)"
+      by (simp_all add: field_simps)
+    then show ?thesis by (intro iffI) (erule (1) big_trans)+
+  qed
+  show "(\<lambda>x. inverse (g x)) \<in> L F (\<lambda>x. inverse (f x))"
+    if *: "f \<in> L F (g)" and **: "eventually (\<lambda>x. f x \<noteq> 0) F" "eventually (\<lambda>x. g x \<noteq> 0) F"
+    for f g :: "'a \<Rightarrow> 'b" and F
+  proof -
+    from * obtain c where c: "c > 0" and ***: "\<forall>\<^sub>F x in F. R (norm (f x)) (c * norm (g x))"
+      by (elim bigE)
+    from ** *** have "eventually (\<lambda>x. R (norm (inverse (g x))) (c * norm (inverse (f x)))) F"
+      by eventually_elim (rule R_E, simp_all add: field_simps norm_inverse norm_divide c)
+    with c show ?thesis by (rule bigI)
+  qed
+  show "L F g \<subseteq> L F (\<lambda>x. f x + g x)" if "f \<in> o[F](g)" for f g :: "'a \<Rightarrow> 'b" and F
+    using plus_aux that by (blast intro!: big_subsetI)
+  show "L F (f) = L F (g)" if "eventually (\<lambda>x. f x = g x) F" for f g :: "'a \<Rightarrow> 'b" and F
+    unfolding L_def by (subst eventually_subst'[OF that]) (rule refl)
+  show "f \<in> L F (h) \<longleftrightarrow> g \<in> L F (h)" if "eventually (\<lambda>x. f x = g x) F"
+    for f g h :: "'a \<Rightarrow> 'b" and F
+    unfolding L_def mem_Collect_eq
+    by (subst (1) eventually_subst'[OF that]) (rule refl)
+  show "L F f \<subseteq> L F g" if "f \<in> L F g" for f g :: "'a \<Rightarrow> 'b" and F
+    using that by (rule big_subsetI)
+  show "L F (f) = L F (g)" if "f \<in> \<Theta>[F](g)" for f g :: "'a \<Rightarrow> 'b" and F
+    using L that unfolding bigtheta_def
+    by (intro equalityI big_subsetI) (auto simp: bigomega_iff_bigo)
+  show "f \<in> L F (h) \<longleftrightarrow> g \<in> L F (h)" if "f \<in> \<Theta>[F](g)" for f g h :: "'a \<Rightarrow> 'b" and F
+    by (rule disjE[OF L])
+      (use that in \<open>auto simp: bigtheta_def bigomega_iff_bigo intro: landau_o.big_trans\<close>)
+  show "(\<lambda>x. h x * f x) \<in> L F (\<lambda>x. h x * g x)" if "f \<in> L F g" for f g h :: "'a \<Rightarrow> 'b" and F
+    using that by (intro big_mult) simp
+  show "f \<in> L F (h)" if "f \<in> L F g" "g \<in> L F h" for f g h :: "'a \<Rightarrow> 'b" and F
+    using that by (rule big_trans)
+  show "(\<lambda>x. f (h x)) \<in> L' G (\<lambda>x. g (h x))"
+    if "f \<in> L F g" and "filterlim h F G"
+    for f g :: "'a \<Rightarrow> 'b" and h :: "'c \<Rightarrow> 'a" and F G
+    using that by (auto simp: L_def L'_def filterlim_iff)
+  show "f \<in> L (sup F G) g" if "f \<in> L F g" "f \<in> L G g"
+    for f g :: "'a \<Rightarrow> 'b" and F G :: "'a filter"
+  proof -
+    from that [THEN bigE] obtain c1 c2
+      where *: "c1 > 0" "c2 > 0"
+        and **: "\<forall>\<^sub>F x in F. R (norm (f x)) (c1 * norm (g x))"
+                "\<forall>\<^sub>F x in G. R (norm (f x)) (c2 * norm (g x))" .
     define c where "c = (if R c1 c2 then c2 else c1)"
-    from c12 have c: "R c1 c" "R c2 c" "c > 0" by (auto simp: c_def dest: R_linear)
-    with c12(2,4) have "eventually (\<lambda>x. R (norm (f x)) (c * norm (g x))) F"
-                     "eventually (\<lambda>x. R (norm (f x)) (c * norm (g x))) G"
+    from * have c: "R c1 c" "R c2 c" "c > 0"
+      by (auto simp: c_def dest: R_linear)
+    with ** have "eventually (\<lambda>x. R (norm (f x)) (c * norm (g x))) F"
+                 "eventually (\<lambda>x. R (norm (f x)) (c * norm (g x))) G"
       by (force elim: eventually_mono intro: R_trans[OF _ R_mult_right_mono])+
-    with c show "f \<in> L (sup F G) g" by (auto simp: L_def eventually_sup)
-  }
-  {
-    fix f g :: "'a \<Rightarrow> 'b" and h :: "'c \<Rightarrow> 'a" and F G :: "'a filter"
-    assume "(f \<in> L F g)"
-    thus "((\<lambda>x. f (h x)) \<in> L' (filtercomap h F) (\<lambda>x. g (h x)))"
-      unfolding L_def L'_def by auto
-  }
+    with c show "f \<in> L (sup F G) g"
+      by (auto simp: L_def eventually_sup)
+  qed
+  show "((\<lambda>x. f (h x)) \<in> L' (filtercomap h F) (\<lambda>x. g (h x)))" if "(f \<in> L F g)"
+    for f g :: "'a \<Rightarrow> 'b" and h :: "'c \<Rightarrow> 'a" and F G :: "'a filter"
+    using that unfolding L_def L'_def by auto
 qed (auto simp: L_def Lr_def eventually_filtermap L'_def
           intro: filter_leD exI[of _ "1::real"])
 
 sublocale small: landau_symbol l l' lr
 proof
-  {
-    fix c :: 'b and f :: "'a \<Rightarrow> 'b" and F assume "c \<noteq> 0"
-    hence "(\<lambda>x. c * f x) \<in> L F f" by (intro bigI[of "norm c"]) (simp_all add: norm_mult)
-  } note A = this
-  {
-    fix c :: 'b and f :: "'a \<Rightarrow> 'b" and F assume "c \<noteq> 0"
-    from \<open>c \<noteq> 0\<close> and A[of c f] and A[of "inverse c" "\<lambda>x. c * f x"] 
-      show "l F (\<lambda>x. c * f x) = l F f" 
-        by (intro equalityI small_subsetI) (simp_all add: field_simps)
-  }
-  {
-    fix c :: 'b and f g :: "'a \<Rightarrow> 'b" and F assume "c \<noteq> 0"
-    from \<open>c \<noteq> 0\<close> and A[of c f] and A[of "inverse c" "\<lambda>x. c * f x"]
-      have "(\<lambda>x. c * f x) \<in> L F f" "f \<in> L F (\<lambda>x. c * f x)" by (simp_all add: field_simps)
-    thus "((\<lambda>x. c * f x) \<in> l F g) = (f \<in> l F g)" by (intro iffI) (erule (1) big_small_trans)+
-  }
-  {
-    fix f g :: "'a \<Rightarrow> 'b" and F assume "f \<in> o[F](g)"
-    with plus_aux show "l F g \<subseteq> l F (\<lambda>x. f x + g x)" by (blast intro!: small_subsetI) 
-  }
-  {
-    fix f g :: "'a \<Rightarrow> 'b" and F assume A: "f \<in> l F (g)"
-    assume B: "eventually (\<lambda>x. f x \<noteq> 0) F" "eventually (\<lambda>x. g x \<noteq> 0) F"
-    show "(\<lambda>x. inverse (g x)) \<in> l F (\<lambda>x. inverse (f x))"
-    proof (rule smallI)
-      fix c :: real assume c: "c > 0"
-      from B smallD[OF A c] 
-        show "eventually (\<lambda>x. R (norm (inverse (g x))) (c * norm (inverse (f x)))) F"
-        by eventually_elim (rule R_E, simp_all add: field_simps norm_inverse norm_divide)
-    qed
-  }
-  {
-    fix f g :: "'a \<Rightarrow> 'b" and F assume A: "eventually (\<lambda>x. f x = g x) F"
-    show "l F (f) = l F (g)" unfolding l_def by (subst eventually_subst'[OF A]) (rule refl)
-  }
-  {
-    fix f g h :: "'a \<Rightarrow> 'b" and F assume A: "eventually (\<lambda>x. f x = g x) F"
-    show "f \<in> l F (h) \<longleftrightarrow> g \<in> l F (h)" unfolding l_def mem_Collect_eq
-      by (subst (1) eventually_subst'[OF A]) (rule refl)
-  }
-  {
-    fix f g :: "'a \<Rightarrow> 'b" and F assume "f \<in> l F g" 
-    thus "l F f \<subseteq> l F g" by (intro small_subsetI small_imp_big)
-  }
-  {
-    fix f g :: "'a \<Rightarrow> 'b" and F assume A: "f \<in> \<Theta>[F](g)"
+  have A: "(\<lambda>x. c * f x) \<in> L F f" if "c \<noteq> 0" for c :: 'b and f :: "'a \<Rightarrow> 'b" and F
+    using that by (intro bigI[of "norm c"]) (simp_all add: norm_mult)
+  show "l F (\<lambda>x. c * f x) = l F f" if "c \<noteq> 0" for c :: 'b and f :: "'a \<Rightarrow> 'b" and F
+    using that and A[of c f] and A[of "inverse c" "\<lambda>x. c * f x"]
+    by (intro equalityI small_subsetI) (simp_all add: field_simps)
+  show "((\<lambda>x. c * f x) \<in> l F g) = (f \<in> l F g)" if "c \<noteq> 0" for c :: 'b and f g :: "'a \<Rightarrow> 'b" and F
+  proof -
+    from that and A[of c f] and A[of "inverse c" "\<lambda>x. c * f x"]
+    have "(\<lambda>x. c * f x) \<in> L F f" "f \<in> L F (\<lambda>x. c * f x)"
+      by (simp_all add: field_simps)
+    then show ?thesis
+      by (intro iffI) (erule (1) big_small_trans)+
+  qed
+  show "l F g \<subseteq> l F (\<lambda>x. f x + g x)" if "f \<in> o[F](g)" for f g :: "'a \<Rightarrow> 'b" and F
+    using plus_aux that by (blast intro!: small_subsetI)
+  show "(\<lambda>x. inverse (g x)) \<in> l F (\<lambda>x. inverse (f x))"
+    if A: "f \<in> l F (g)" and B: "eventually (\<lambda>x. f x \<noteq> 0) F" "eventually (\<lambda>x. g x \<noteq> 0) F"
+    for f g :: "'a \<Rightarrow> 'b" and F
+  proof (rule smallI)
+    fix c :: real assume c: "c > 0"
+    from B smallD[OF A c]
+    show "eventually (\<lambda>x. R (norm (inverse (g x))) (c * norm (inverse (f x)))) F"
+      by eventually_elim (rule R_E, simp_all add: field_simps norm_inverse norm_divide)
+  qed
+  show "l F (f) = l F (g)" if "eventually (\<lambda>x. f x = g x) F" for f g :: "'a \<Rightarrow> 'b" and F
+    unfolding l_def by (subst eventually_subst'[OF that]) (rule refl)
+  show "f \<in> l F (h) \<longleftrightarrow> g \<in> l F (h)" if "eventually (\<lambda>x. f x = g x) F" for f g h :: "'a \<Rightarrow> 'b" and F
+    unfolding l_def mem_Collect_eq by (subst (1) eventually_subst'[OF that]) (rule refl)
+  show "l F f \<subseteq> l F g" if "f \<in> l F g" for f g :: "'a \<Rightarrow> 'b" and F
+    using that by (intro small_subsetI small_imp_big)
+  show "l F (f) = l F (g)" if "f \<in> \<Theta>[F](g)" for f g :: "'a \<Rightarrow> 'b" and F
+  proof -
     have L: "L = bigo \<or> L = bigomega"
       by (rule R_E) (auto simp: bigo_def L_def bigomega_def fun_eq_iff)
-    with A show "l F (f) = l F (g)" unfolding bigtheta_def
+    with that show ?thesis unfolding bigtheta_def
       by (intro equalityI small_subsetI) (auto simp: bigomega_iff_bigo)
+  qed
+  show "f \<in> l F (h) \<longleftrightarrow> g \<in> l F (h)" if "f \<in> \<Theta>[F](g)" for f g h :: "'a \<Rightarrow> 'b" and F
+  proof -
     have l: "l = smallo \<or> l = smallomega"
       by (rule R_E) (auto simp: smallo_def l_def smallomega_def fun_eq_iff)
-    fix h:: "'a \<Rightarrow> 'b"
-    show "f \<in> l F (h) \<longleftrightarrow> g \<in> l F (h)" by (rule disjE[OF l]) 
-      (insert A, auto simp: bigtheta_def bigomega_iff_bigo smallomega_iff_smallo 
-       intro: landau_o.big_small_trans landau_o.small_big_trans)
-  }
-  {
-    fix f g h :: "'a \<Rightarrow> 'b" and F assume "f \<in> l F g"
-    thus "(\<lambda>x. h x * f x) \<in> l F (\<lambda>x. h x * g x)" by (intro big_small_mult) simp
-  }
-  {
-    fix f g h :: "'a \<Rightarrow> 'b" and F assume "f \<in> l F g" "g \<in> l F h"
-    thus "f \<in> l F (h)" by (rule small_trans)
-  }
-  {
-    fix f g :: "'a \<Rightarrow> 'b" and h :: "'c \<Rightarrow> 'a" and F G
-    assume "f \<in> l F g" and "filterlim h F G"
-    thus "(\<lambda>x. f (h x)) \<in> l' G (\<lambda>x. g (h x))"
-      by (auto simp: l_def l'_def filterlim_iff)
-  }
-  {
-    fix f g :: "'a \<Rightarrow> 'b" and h :: "'c \<Rightarrow> 'a" and F G :: "'a filter"
-    assume "(f \<in> l F g)"
-    thus "((\<lambda>x. f (h x)) \<in> l' (filtercomap h F) (\<lambda>x. g (h x)))"
-      unfolding l_def l'_def by auto
-  }
+    show ?thesis
+      by (rule disjE[OF l])
+        (use that in \<open>auto simp: bigtheta_def bigomega_iff_bigo smallomega_iff_smallo
+          intro: landau_o.big_small_trans landau_o.small_big_trans\<close>)
+  qed
+  show "(\<lambda>x. h x * f x) \<in> l F (\<lambda>x. h x * g x)" if "f \<in> l F g" for f g h :: "'a \<Rightarrow> 'b" and F
+    using that by (intro big_small_mult) simp
+  show "f \<in> l F (h)" if "f \<in> l F g" "g \<in> l F h" for f g h :: "'a \<Rightarrow> 'b" and F
+    using that by (rule small_trans)
+  show "(\<lambda>x. f (h x)) \<in> l' G (\<lambda>x. g (h x))" if "f \<in> l F g" and "filterlim h F G"
+    for f g :: "'a \<Rightarrow> 'b" and h :: "'c \<Rightarrow> 'a" and F G
+    using that by (auto simp: l_def l'_def filterlim_iff)
+  show "((\<lambda>x. f (h x)) \<in> l' (filtercomap h F) (\<lambda>x. g (h x)))" if "f \<in> l F g"
+    for f g :: "'a \<Rightarrow> 'b" and h :: "'c \<Rightarrow> 'a" and F G :: "'a filter"
+    using that unfolding l_def l'_def by auto
 qed (auto simp: l_def lr_def eventually_filtermap l'_def eventually_sup intro: filter_leD)
 
 
 text \<open>These rules allow chaining of Landau symbol propositions in Isar with "also".\<close>
 
 lemma big_mult_1:    "f \<in> L F (g) \<Longrightarrow> (\<lambda>_. 1) \<in> L F (h) \<Longrightarrow> f \<in> L F (\<lambda>x. g x * h x)"
   and big_mult_1':   "(\<lambda>_. 1) \<in> L F (g) \<Longrightarrow> f \<in> L F (h) \<Longrightarrow> f \<in> L F (\<lambda>x. g x * h x)"
   and small_mult_1:  "f \<in> l F (g) \<Longrightarrow> (\<lambda>_. 1) \<in> L F (h) \<Longrightarrow> f \<in> l F (\<lambda>x. g x * h x)"
   and small_mult_1': "(\<lambda>_. 1) \<in> L F (g) \<Longrightarrow> f \<in> l F (h) \<Longrightarrow> f \<in> l F (\<lambda>x. g x * h x)"
   and small_mult_1'':  "f \<in> L F (g) \<Longrightarrow> (\<lambda>_. 1) \<in> l F (h) \<Longrightarrow> f \<in> l F (\<lambda>x. g x * h x)"
   and small_mult_1''': "(\<lambda>_. 1) \<in> l F (g) \<Longrightarrow> f \<in> L F (h) \<Longrightarrow> f \<in> l F (\<lambda>x. g x * h x)"
   by (drule (1) big.mult big_small_mult small_big_mult, simp)+
 
 lemma big_1_mult:    "f \<in> L F (g) \<Longrightarrow> h \<in> L F (\<lambda>_. 1) \<Longrightarrow> (\<lambda>x. f x * h x) \<in> L F (g)"
   and big_1_mult':   "h \<in> L F (\<lambda>_. 1) \<Longrightarrow> f \<in> L F (g) \<Longrightarrow> (\<lambda>x. f x * h x) \<in> L F (g)"
   and small_1_mult:  "f \<in> l F (g) \<Longrightarrow> h \<in> L F (\<lambda>_. 1) \<Longrightarrow> (\<lambda>x. f x * h x) \<in> l F (g)"
   and small_1_mult': "h \<in> L F (\<lambda>_. 1) \<Longrightarrow> f \<in> l F (g) \<Longrightarrow> (\<lambda>x. f x * h x) \<in> l F (g)"
   and small_1_mult'':  "f \<in> L F (g) \<Longrightarrow> h \<in> l F (\<lambda>_. 1) \<Longrightarrow> (\<lambda>x. f x * h x) \<in> l F (g)"
   and small_1_mult''': "h \<in> l F (\<lambda>_. 1) \<Longrightarrow> f \<in> L F (g) \<Longrightarrow> (\<lambda>x. f x * h x) \<in> l F (g)"
   by (drule (1) big.mult big_small_mult small_big_mult, simp)+
 
-lemmas mult_1_trans = 
+lemmas mult_1_trans =
   big_mult_1 big_mult_1' small_mult_1 small_mult_1' small_mult_1'' small_mult_1'''
   big_1_mult big_1_mult' small_1_mult small_1_mult' small_1_mult'' small_1_mult'''
 
 lemma big_equal_iff_bigtheta: "L F (f) = L F (g) \<longleftrightarrow> f \<in> \<Theta>[F](g)"
 proof
   have L: "L = bigo \<or> L = bigomega"
     by (rule R_E) (auto simp: fun_eq_iff L_def bigo_def bigomega_def)
   fix f g :: "'a \<Rightarrow> 'b" assume "L F (f) = L F (g)"
   with big_refl[of f F] big_refl[of g F] have "f \<in> L F (g)" "g \<in> L F (f)" by simp_all
   thus "f \<in> \<Theta>[F](g)" using L unfolding bigtheta_def by (auto simp: bigomega_iff_bigo)
 qed (rule big.cong_bigtheta)
 
 lemma big_prod:
   assumes "\<And>x. x \<in> A \<Longrightarrow> f x \<in> L F (g x)"
   shows   "(\<lambda>y. \<Prod>x\<in>A. f x y) \<in> L F (\<lambda>y. \<Prod>x\<in>A. g x y)"
   using assms by (induction A rule: infinite_finite_induct) (auto intro!: big.mult)
 
 lemma big_prod_in_1:
   assumes "\<And>x. x \<in> A \<Longrightarrow> f x \<in> L F (\<lambda>_. 1)"
   shows   "(\<lambda>y. \<Prod>x\<in>A. f x y) \<in> L F (\<lambda>_. 1)"
   using assms by (induction A rule: infinite_finite_induct) (auto intro!: big.mult_in_1)
 
 end
 
 
 context landau_symbol
 begin
-  
+
 lemma plus_absorb1:
   assumes "f \<in> o[F](g)"
   shows   "L F (\<lambda>x. f x + g x) = L F (g)"
 proof (intro equalityI)
   from plus_subset1 and assms show "L F g \<subseteq> L F (\<lambda>x. f x + g x)" .
   from landau_o.small.plus_subset1[OF assms] and assms have "(\<lambda>x. -f x) \<in> o[F](\<lambda>x. f x + g x)"
     by (auto simp: landau_o.small.uminus_in_iff)
   from plus_subset1[OF this] show "L F (\<lambda>x. f x + g x) \<subseteq> L F (g)" by simp
 qed
 
 lemma plus_absorb2: "g \<in> o[F](f) \<Longrightarrow> L F (\<lambda>x. f x + g x) = L F (f)"
   using plus_absorb1[of g F f] by (simp add: add.commute)
 
 lemma diff_absorb1: "f \<in> o[F](g) \<Longrightarrow> L F (\<lambda>x. f x - g x) = L F (g)"
   by (simp only: diff_conv_add_uminus plus_absorb1 landau_o.small.uminus uminus)
 
 lemma diff_absorb2: "g \<in> o[F](f) \<Longrightarrow> L F (\<lambda>x. f x - g x) = L F (f)"
   by (simp only: diff_conv_add_uminus plus_absorb2 landau_o.small.uminus_in_iff)
 
 lemmas absorb = plus_absorb1 plus_absorb2 diff_absorb1 diff_absorb2
 
 end
 
 
 lemma bigthetaI [intro]: "f \<in> O[F](g) \<Longrightarrow> f \<in> \<Omega>[F](g) \<Longrightarrow> f \<in> \<Theta>[F](g)"
   unfolding bigtheta_def bigomega_def by blast
 
-lemma bigthetaD1 [dest]: "f \<in> \<Theta>[F](g) \<Longrightarrow> f \<in> O[F](g)" 
+lemma bigthetaD1 [dest]: "f \<in> \<Theta>[F](g) \<Longrightarrow> f \<in> O[F](g)"
   and bigthetaD2 [dest]: "f \<in> \<Theta>[F](g) \<Longrightarrow> f \<in> \<Omega>[F](g)"
   unfolding bigtheta_def bigo_def bigomega_def by blast+
 
 lemma bigtheta_refl [simp]: "f \<in> \<Theta>[F](f)"
   unfolding bigtheta_def by simp
 
 lemma bigtheta_sym: "f \<in> \<Theta>[F](g) \<longleftrightarrow> g \<in> \<Theta>[F](f)"
   unfolding bigtheta_def by (auto simp: bigomega_iff_bigo)
 
 lemmas landau_flip =
   bigomega_iff_bigo[symmetric] smallomega_iff_smallo[symmetric]
   bigomega_iff_bigo smallomega_iff_smallo bigtheta_sym
 
 
 interpretation landau_theta: landau_symbol bigtheta bigtheta bigtheta
 proof
   fix f g :: "'a \<Rightarrow> 'b" and F
   assume "f \<in> o[F](g)"
   hence "O[F](g) \<subseteq> O[F](\<lambda>x. f x + g x)" "\<Omega>[F](g) \<subseteq> \<Omega>[F](\<lambda>x. f x + g x)"
     by (rule landau_o.big.plus_subset1 landau_omega.big.plus_subset1)+
   thus "\<Theta>[F](g) \<subseteq> \<Theta>[F](\<lambda>x. f x + g x)" unfolding bigtheta_def by blast
 next
-  fix f g :: "'a \<Rightarrow> 'b" and F 
+  fix f g :: "'a \<Rightarrow> 'b" and F
   assume "f \<in> \<Theta>[F](g)"
-  thus A: "\<Theta>[F](f) = \<Theta>[F](g)" 
+  thus A: "\<Theta>[F](f) = \<Theta>[F](g)"
     apply (subst (1 2) bigtheta_def)
     apply (subst landau_o.big.cong_bigtheta landau_omega.big.cong_bigtheta, assumption)+
     apply (rule refl)
     done
   thus "\<Theta>[F](f) \<subseteq> \<Theta>[F](g)" by simp
   fix h :: "'a \<Rightarrow> 'b"
   show "f \<in> \<Theta>[F](h) \<longleftrightarrow> g \<in> \<Theta>[F](h)" by (subst (1 2) bigtheta_sym) (simp add: A)
 next
   fix f g h :: "'a \<Rightarrow> 'b" and F
   assume "f \<in> \<Theta>[F](g)" "g \<in> \<Theta>[F](h)"
   thus "f \<in> \<Theta>[F](h)" unfolding bigtheta_def
     by (blast intro: landau_o.big.trans landau_omega.big.trans)
 next
   fix f :: "'a \<Rightarrow> 'b" and F1 F2 :: "'a filter"
   assume "F1 \<le> F2"
   thus "\<Theta>[F2](f) \<subseteq> \<Theta>[F1](f)"
     by (auto simp: bigtheta_def intro: landau_o.big.filter_mono landau_omega.big.filter_mono)
-qed (auto simp: bigtheta_def landau_o.big.norm_iff 
-                landau_o.big.cmult landau_omega.big.cmult 
-                landau_o.big.cmult_in_iff landau_omega.big.cmult_in_iff 
+qed (auto simp: bigtheta_def landau_o.big.norm_iff
+                landau_o.big.cmult landau_omega.big.cmult
+                landau_o.big.cmult_in_iff landau_omega.big.cmult_in_iff
                 landau_o.big.in_cong landau_omega.big.in_cong
                 landau_o.big.mult landau_omega.big.mult
-                landau_o.big.inverse landau_omega.big.inverse 
+                landau_o.big.inverse landau_omega.big.inverse
                 landau_o.big.compose landau_omega.big.compose
                 landau_o.big.bot' landau_omega.big.bot'
                 landau_o.big.in_filtermap_iff landau_omega.big.in_filtermap_iff
                 landau_o.big.sup landau_omega.big.sup
                 landau_o.big.filtercomap landau_omega.big.filtercomap
           dest: landau_o.big.cong landau_omega.big.cong)
 
-lemmas landau_symbols = 
+lemmas landau_symbols =
   landau_o.big.landau_symbol_axioms landau_o.small.landau_symbol_axioms
-  landau_omega.big.landau_symbol_axioms landau_omega.small.landau_symbol_axioms 
+  landau_omega.big.landau_symbol_axioms landau_omega.small.landau_symbol_axioms
   landau_theta.landau_symbol_axioms
 
 lemma bigoI [intro]:
   assumes "eventually (\<lambda>x. (norm (f x)) \<le> c * (norm (g x))) F"
   shows   "f \<in> O[F](g)"
 proof (rule landau_o.bigI)
   show "max 1 c > 0" by simp
-  note assms
-  moreover have "\<And>x. c * (norm (g x)) \<le> max 1 c * (norm (g x))" by (simp add: mult_right_mono)
-  ultimately show "eventually (\<lambda>x. (norm (f x)) \<le> max 1 c * (norm (g x))) F"
+  have "c * (norm (g x)) \<le> max 1 c * (norm (g x))" for x
+    by (simp add: mult_right_mono)
+  with assms show "eventually (\<lambda>x. (norm (f x)) \<le> max 1 c * (norm (g x))) F"
     by (auto elim!: eventually_mono dest: order.trans)
 qed
 
 lemma smallomegaD [dest]:
   assumes "f \<in> \<omega>[F](g)"
   shows   "eventually (\<lambda>x. (norm (f x)) \<ge> c * (norm (g x))) F"
 proof (cases "c > 0")
   case False
-  show ?thesis 
+  show ?thesis
     by (intro always_eventually allI, rule order.trans[of _ 0])
        (insert False, auto intro!: mult_nonpos_nonneg)
 qed (blast dest: landau_omega.smallD[OF assms, of c])
 
-  
+
 lemma bigthetaI':
   assumes "c1 > 0" "c2 > 0"
   assumes "eventually (\<lambda>x. c1 * (norm (g x)) \<le> (norm (f x)) \<and> (norm (f x)) \<le> c2 * (norm (g x))) F"
   shows   "f \<in> \<Theta>[F](g)"
 apply (rule bigthetaI)
 apply (rule landau_o.bigI[OF assms(2)]) using assms(3) apply (eventually_elim, simp)
 apply (rule landau_omega.bigI[OF assms(1)]) using assms(3) apply (eventually_elim, simp)
 done
 
 lemma bigthetaI_cong: "eventually (\<lambda>x. f x = g x) F \<Longrightarrow> f \<in> \<Theta>[F](g)"
   by (intro bigthetaI'[of 1 1]) (auto elim!: eventually_mono)
 
-lemma (in landau_symbol) ev_eq_trans1: 
+lemma (in landau_symbol) ev_eq_trans1:
   "f \<in> L F (\<lambda>x. g x (h x)) \<Longrightarrow> eventually (\<lambda>x. h x = h' x) F \<Longrightarrow> f \<in> L F (\<lambda>x. g x (h' x))"
   by (rule bigtheta_trans1[OF _ bigthetaI_cong]) (auto elim!: eventually_mono)
 
-lemma (in landau_symbol) ev_eq_trans2: 
+lemma (in landau_symbol) ev_eq_trans2:
   "eventually (\<lambda>x. f x = f' x) F \<Longrightarrow> (\<lambda>x. g x (f' x)) \<in> L F (h) \<Longrightarrow> (\<lambda>x. g x (f x)) \<in> L F (h)"
   by (rule bigtheta_trans2[OF bigthetaI_cong]) (auto elim!: eventually_mono)
 
 declare landau_o.smallI landau_omega.bigI landau_omega.smallI [intro]
 declare landau_o.bigE landau_omega.bigE [elim]
 declare landau_o.smallD
 
-lemma (in landau_symbol) bigtheta_trans1': 
+lemma (in landau_symbol) bigtheta_trans1':
   "f \<in> L F (g) \<Longrightarrow> h \<in> \<Theta>[F](g) \<Longrightarrow> f \<in> L F (h)"
   by (subst cong_bigtheta[symmetric]) (simp add: bigtheta_sym)
 
-lemma (in landau_symbol) bigtheta_trans2': 
+lemma (in landau_symbol) bigtheta_trans2':
   "g \<in> \<Theta>[F](f) \<Longrightarrow> g \<in> L F (h) \<Longrightarrow> f \<in> L F (h)"
   by (rule bigtheta_trans2, subst bigtheta_sym)
 
 lemma bigo_bigomega_trans:      "f \<in> O[F](g) \<Longrightarrow> h \<in> \<Omega>[F](g) \<Longrightarrow> f \<in> O[F](h)"
   and bigo_smallomega_trans:    "f \<in> O[F](g) \<Longrightarrow> h \<in> \<omega>[F](g) \<Longrightarrow> f \<in> o[F](h)"
   and smallo_bigomega_trans:    "f \<in> o[F](g) \<Longrightarrow> h \<in> \<Omega>[F](g) \<Longrightarrow> f \<in> o[F](h)"
   and smallo_smallomega_trans:  "f \<in> o[F](g) \<Longrightarrow> h \<in> \<omega>[F](g) \<Longrightarrow> f \<in> o[F](h)"
   and bigomega_bigo_trans:      "f \<in> \<Omega>[F](g) \<Longrightarrow> h \<in> O[F](g) \<Longrightarrow> f \<in> \<Omega>[F](h)"
   and bigomega_smallo_trans:    "f \<in> \<Omega>[F](g) \<Longrightarrow> h \<in> o[F](g) \<Longrightarrow> f \<in> \<omega>[F](h)"
   and smallomega_bigo_trans:    "f \<in> \<omega>[F](g) \<Longrightarrow> h \<in> O[F](g) \<Longrightarrow> f \<in> \<omega>[F](h)"
   and smallomega_smallo_trans:  "f \<in> \<omega>[F](g) \<Longrightarrow> h \<in> o[F](g) \<Longrightarrow> f \<in> \<omega>[F](h)"
   by (unfold bigomega_iff_bigo smallomega_iff_smallo)
-     (erule (1) landau_o.big_trans landau_o.big_small_trans landau_o.small_big_trans 
+     (erule (1) landau_o.big_trans landau_o.big_small_trans landau_o.small_big_trans
                 landau_o.big_trans landau_o.small_trans)+
 
 lemmas landau_trans_lift [trans] =
   landau_symbols[THEN landau_symbol.lift_trans]
   landau_symbols[THEN landau_symbol.lift_trans']
   landau_symbols[THEN landau_symbol.lift_trans_bigtheta]
   landau_symbols[THEN landau_symbol.lift_trans_bigtheta']
 
 lemmas landau_mult_1_trans [trans] =
   landau_o.mult_1_trans landau_omega.mult_1_trans
 
-lemmas landau_trans [trans] = 
+lemmas landau_trans [trans] =
   landau_symbols[THEN landau_symbol.bigtheta_trans1]
   landau_symbols[THEN landau_symbol.bigtheta_trans2]
   landau_symbols[THEN landau_symbol.bigtheta_trans1']
   landau_symbols[THEN landau_symbol.bigtheta_trans2']
   landau_symbols[THEN landau_symbol.ev_eq_trans1]
   landau_symbols[THEN landau_symbol.ev_eq_trans2]
 
   landau_o.big_trans landau_o.small_trans landau_o.small_big_trans landau_o.big_small_trans
-  landau_omega.big_trans landau_omega.small_trans 
+  landau_omega.big_trans landau_omega.small_trans
     landau_omega.small_big_trans landau_omega.big_small_trans
 
-  bigo_bigomega_trans bigo_smallomega_trans smallo_bigomega_trans smallo_smallomega_trans 
+  bigo_bigomega_trans bigo_smallomega_trans smallo_bigomega_trans smallo_smallomega_trans
   bigomega_bigo_trans bigomega_smallo_trans smallomega_bigo_trans smallomega_smallo_trans
 
-lemma bigtheta_inverse [simp]: 
+lemma bigtheta_inverse [simp]:
   shows "(\<lambda>x. inverse (f x)) \<in> \<Theta>[F](\<lambda>x. inverse (g x)) \<longleftrightarrow> f \<in> \<Theta>[F](g)"
-proof-
-  {
-    fix f g :: "'a \<Rightarrow> 'b" and F assume A: "f \<in> \<Theta>[F](g)"
-    then guess c1 c2 :: real unfolding bigtheta_def by (elim landau_o.bigE landau_omega.bigE IntE)
-    note c = this
-    from c(3) have "inverse c2 > 0" by simp
-    moreover from c(2,4)
-      have "eventually (\<lambda>x. norm (inverse (f x)) \<le> inverse c2 * norm (inverse (g x))) F"
+proof -
+  have "(\<lambda>x. inverse (f x)) \<in> O[F](\<lambda>x. inverse (g x))"
+    if A: "f \<in> \<Theta>[F](g)"
+    for f g :: "'a \<Rightarrow> 'b" and F
+  proof -
+    from A obtain c1 c2 :: real where *: "c1 > 0" "c2 > 0"
+      and **: "\<forall>\<^sub>F x in F. norm (f x) \<le> c1 * norm (g x)"
+              "\<forall>\<^sub>F x in F. c2 * norm (g x) \<le> norm (f x)"
+      unfolding bigtheta_def by (elim landau_o.bigE landau_omega.bigE IntE)
+    from \<open>c2 > 0\<close> have c2: "inverse c2 > 0" by simp
+    from ** have "eventually (\<lambda>x. norm (inverse (f x)) \<le> inverse c2 * norm (inverse (g x))) F"
     proof eventually_elim
-      fix x assume A: "(norm (f x)) \<le> c1 * (norm (g x))" "c2 * (norm (g x)) \<le> (norm (f x))"
-      from A c(1,3) have "f x = 0 \<longleftrightarrow> g x = 0" by (auto simp: field_simps mult_le_0_iff)
-      with A c(1,3) show "norm (inverse (f x)) \<le> inverse c2 * norm (inverse (g x))"
+      fix x assume A: "norm (f x) \<le> c1 * norm (g x)" "c2 * norm (g x) \<le> norm (f x)"
+      from A * have "f x = 0 \<longleftrightarrow> g x = 0"
+        by (auto simp: field_simps mult_le_0_iff)
+      with A * show "norm (inverse (f x)) \<le> inverse c2 * norm (inverse (g x))"
         by (force simp: field_simps norm_inverse norm_divide)
     qed
-    ultimately have "(\<lambda>x. inverse (f x)) \<in> O[F](\<lambda>x. inverse (g x))" by (rule landau_o.bigI)
-  }
-  thus ?thesis unfolding bigtheta_def 
+    with c2 show ?thesis by (rule landau_o.bigI)
+  qed
+  then show ?thesis
+    unfolding bigtheta_def
     by (force simp: bigomega_iff_bigo bigtheta_sym)
 qed
 
 lemma bigtheta_divide:
   assumes "f1 \<in> \<Theta>(f2)" "g1 \<in> \<Theta>(g2)"
   shows   "(\<lambda>x. f1 x / g1 x) \<in> \<Theta>(\<lambda>x. f2 x / g2 x)"
   by (subst (1 2) divide_inverse, intro landau_theta.mult) (simp_all add: bigtheta_inverse assms)
 
 lemma eventually_nonzero_bigtheta:
   assumes "f \<in> \<Theta>[F](g)"
   shows   "eventually (\<lambda>x. f x \<noteq> 0) F \<longleftrightarrow> eventually (\<lambda>x. g x \<noteq> 0) F"
-proof-
-  {
-    fix f g :: "'a \<Rightarrow> 'b" and F assume A: "f \<in> \<Theta>[F](g)" and B: "eventually (\<lambda>x. f x \<noteq> 0) F"
-    from A guess c1 c2 unfolding bigtheta_def by (elim landau_o.bigE landau_omega.bigE IntE)
-    from B this(2,4) have "eventually (\<lambda>x. g x \<noteq> 0) F" by eventually_elim auto
-  }
+proof -
+  have "eventually (\<lambda>x. g x \<noteq> 0) F"
+    if A: "f \<in> \<Theta>[F](g)" and B: "eventually (\<lambda>x. f x \<noteq> 0) F"
+    for f g :: "'a \<Rightarrow> 'b"
+  proof -
+    from A obtain c1 c2 where
+      "\<forall>\<^sub>F x in F. norm (f x) \<le> c1 * norm (g x)"
+      "\<forall>\<^sub>F x in F. c2 * norm (g x) \<le> norm (f x)"
+      unfolding bigtheta_def by (elim landau_o.bigE landau_omega.bigE IntE)
+    with B show ?thesis by eventually_elim auto
+  qed
   with assms show ?thesis by (force simp: bigtheta_sym)
 qed
 
 
 subsection \<open>Landau symbols and limits\<close>
 
 lemma bigoI_tendsto_norm:
   fixes f g
   assumes "((\<lambda>x. norm (f x / g x)) \<longlongrightarrow> c) F"
   assumes "eventually (\<lambda>x. g x \<noteq> 0) F"
   shows   "f \<in> O[F](g)"
 proof (rule bigoI)
-  from assms have "eventually (\<lambda>x. dist (norm (f x / g x)) c < 1) F" 
+  from assms have "eventually (\<lambda>x. dist (norm (f x / g x)) c < 1) F"
     using tendstoD by force
   thus "eventually (\<lambda>x. (norm (f x)) \<le> (norm c + 1) * (norm (g x))) F"
     unfolding dist_real_def using assms(2)
   proof eventually_elim
     case (elim x)
     have "(norm (f x)) - norm c * (norm (g x)) \<le> norm ((norm (f x)) - c * (norm (g x)))"
       unfolding norm_mult [symmetric] using norm_triangle_ineq2[of "norm (f x)" "c * norm (g x)"]
       by (simp add: norm_mult abs_mult)
     also from elim have "\<dots> = norm (norm (g x)) * norm (norm (f x / g x) - c)"
       unfolding norm_mult [symmetric] by (simp add: algebra_simps norm_divide)
     also from elim have "norm (norm (f x / g x) - c) \<le> 1" by simp
-    hence "norm (norm (g x)) * norm (norm (f x / g x) - c) \<le> norm (norm (g x)) * 1" 
+    hence "norm (norm (g x)) * norm (norm (f x / g x) - c) \<le> norm (norm (g x)) * 1"
       by (rule mult_left_mono) simp_all
     finally show ?case by (simp add: algebra_simps)
   qed
 qed
 
 lemma bigoI_tendsto:
   assumes "((\<lambda>x. f x / g x) \<longlongrightarrow> c) F"
   assumes "eventually (\<lambda>x. g x \<noteq> 0) F"
   shows   "f \<in> O[F](g)"
   using assms by (rule bigoI_tendsto_norm[OF tendsto_norm])
 
 lemma bigomegaI_tendsto_norm:
   assumes c_not_0:  "(c::real) \<noteq> 0"
   assumes lim:      "((\<lambda>x. norm (f x / g x)) \<longlongrightarrow> c) F"
   shows   "f \<in> \<Omega>[F](g)"
 proof (cases "F = bot")
   case False
   show ?thesis
   proof (rule landau_omega.bigI)
     from lim  have "c \<ge> 0" by (rule tendsto_lowerbound) (insert False, simp_all)
     with c_not_0 have "c > 0" by simp
     with c_not_0 show "c/2 > 0" by simp
     from lim have ev: "\<And>\<epsilon>. \<epsilon> > 0 \<Longrightarrow> eventually (\<lambda>x. norm (norm (f x / g x) - c) < \<epsilon>) F"
       by (subst (asm) tendsto_iff) (simp add: dist_real_def)
     from ev[OF \<open>c/2 > 0\<close>] show "eventually (\<lambda>x. (norm (f x)) \<ge> c/2 * (norm (g x))) F"
     proof (eventually_elim)
       fix x assume B: "norm (norm (f x / g x) - c) < c / 2"
       from B have g: "g x \<noteq> 0" by auto
       from B have "-c/2 < -norm (norm (f x / g x) - c)" by simp
       also have "... \<le> norm (f x / g x) - c" by simp
-      finally show "(norm (f x)) \<ge> c/2 * (norm (g x))" using g 
+      finally show "(norm (f x)) \<ge> c/2 * (norm (g x))" using g
         by (simp add: field_simps norm_mult norm_divide)
     qed
   qed
 qed simp
 
 lemma bigomegaI_tendsto:
   assumes c_not_0:  "(c::real) \<noteq> 0"
   assumes lim:      "((\<lambda>x. f x / g x) \<longlongrightarrow> c) F"
   shows   "f \<in> \<Omega>[F](g)"
   by (rule bigomegaI_tendsto_norm[OF _ tendsto_norm, of c]) (insert assms, simp_all)
 
 lemma smallomegaI_filterlim_at_top_norm:
   assumes lim: "filterlim (\<lambda>x. norm (f x / g x)) at_top F"
   shows   "f \<in> \<omega>[F](g)"
 proof (rule landau_omega.smallI)
   fix c :: real assume c_pos: "c > 0"
   from lim have ev: "eventually (\<lambda>x. norm (f x / g x) \<ge> c) F"
     by (subst (asm) filterlim_at_top) simp
   thus "eventually (\<lambda>x. (norm (f x)) \<ge> c * (norm (g x))) F"
   proof eventually_elim
     fix x assume A: "norm (f x / g x) \<ge> c"
     from A c_pos have "g x \<noteq> 0" by auto
     with A show "(norm (f x)) \<ge> c * (norm (g x))" by (simp add: field_simps norm_divide)
   qed
 qed
 
 lemma smallomegaI_filterlim_at_infinity:
   assumes lim: "filterlim (\<lambda>x. f x / g x) at_infinity F"
   shows   "f \<in> \<omega>[F](g)"
 proof (rule smallomegaI_filterlim_at_top_norm)
   from lim show "filterlim (\<lambda>x. norm (f x / g x)) at_top F"
     by (rule filterlim_at_infinity_imp_norm_at_top)
 qed
-  
+
 lemma smallomegaD_filterlim_at_top_norm:
   assumes "f \<in> \<omega>[F](g)"
   assumes "eventually (\<lambda>x. g x \<noteq> 0) F"
   shows   "LIM x F. norm (f x / g x) :> at_top"
 proof (subst filterlim_at_top_gt, clarify)
   fix c :: real assume c: "c > 0"
-  from landau_omega.smallD[OF assms(1) this] assms(2) 
-    show "eventually (\<lambda>x. norm (f x / g x) \<ge> c) F" 
+  from landau_omega.smallD[OF assms(1) this] assms(2)
+    show "eventually (\<lambda>x. norm (f x / g x) \<ge> c) F"
     by eventually_elim (simp add: field_simps norm_divide)
 qed
-  
+
 lemma smallomegaD_filterlim_at_infinity:
   assumes "f \<in> \<omega>[F](g)"
   assumes "eventually (\<lambda>x. g x \<noteq> 0) F"
   shows   "LIM x F. f x / g x :> at_infinity"
   using assms by (intro filterlim_norm_at_top_imp_at_infinity smallomegaD_filterlim_at_top_norm)
 
 lemma smallomega_1_conv_filterlim: "f \<in> \<omega>[F](\<lambda>_. 1) \<longleftrightarrow> filterlim f at_infinity F"
   by (auto intro: smallomegaI_filterlim_at_infinity dest: smallomegaD_filterlim_at_infinity)
 
 lemma smalloI_tendsto:
   assumes lim: "((\<lambda>x. f x / g x) \<longlongrightarrow> 0) F"
   assumes "eventually (\<lambda>x. g x \<noteq> 0) F"
   shows   "f \<in> o[F](g)"
 proof (rule landau_o.smallI)
   fix c :: real assume c_pos: "c > 0"
   from c_pos and lim have ev: "eventually (\<lambda>x. norm (f x / g x) < c) F"
     by (subst (asm) tendsto_iff) (simp add: dist_real_def)
   with assms(2) show "eventually (\<lambda>x. (norm (f x)) \<le> c * (norm (g x))) F"
     by eventually_elim (simp add: field_simps norm_divide)
 qed
 
 lemma smalloD_tendsto:
   assumes "f \<in> o[F](g)"
   shows   "((\<lambda>x. f x / g x) \<longlongrightarrow> 0) F"
 unfolding tendsto_iff
 proof clarify
   fix e :: real assume e: "e > 0"
   hence "e/2 > 0" by simp
   from landau_o.smallD[OF assms this] show "eventually (\<lambda>x. dist (f x / g x) 0 < e) F"
   proof eventually_elim
     fix x assume "(norm (f x)) \<le> e/2 * (norm (g x))"
     with e have "dist (f x / g x) 0 \<le> e/2"
       by (cases "g x = 0") (simp_all add: dist_real_def norm_divide field_simps)
     also from e have "... < e" by simp
     finally show "dist (f x / g x) 0 < e" by simp
   qed
 qed
 
 lemma bigthetaI_tendsto_norm:
   assumes c_not_0: "(c::real) \<noteq> 0"
   assumes lim:     "((\<lambda>x. norm (f x / g x)) \<longlongrightarrow> c) F"
   shows   "f \<in> \<Theta>[F](g)"
 proof (rule bigthetaI)
   from c_not_0 have "\<bar>c\<bar> > 0" by simp
   with lim have "eventually (\<lambda>x. norm (norm (f x / g x) - c) < \<bar>c\<bar>) F"
     by (subst (asm) tendsto_iff) (simp add: dist_real_def)
   hence g: "eventually (\<lambda>x. g x \<noteq> 0) F" by eventually_elim (auto simp add: field_simps)
 
   from lim g show "f \<in> O[F](g)" by (rule bigoI_tendsto_norm)
   from c_not_0 and lim show "f \<in> \<Omega>[F](g)" by (rule bigomegaI_tendsto_norm)
 qed
 
 lemma bigthetaI_tendsto:
   assumes c_not_0: "(c::real) \<noteq> 0"
   assumes lim:     "((\<lambda>x. f x / g x) \<longlongrightarrow> c) F"
   shows   "f \<in> \<Theta>[F](g)"
   using assms by (intro bigthetaI_tendsto_norm[OF _ tendsto_norm, of "c"]) simp_all
 
 lemma tendsto_add_smallo:
   assumes "(f1 \<longlongrightarrow> a) F"
   assumes "f2 \<in> o[F](f1)"
   shows   "((\<lambda>x. f1 x + f2 x) \<longlongrightarrow> a) F"
 proof (subst filterlim_cong[OF refl refl])
-  from landau_o.smallD[OF assms(2) zero_less_one] 
+  from landau_o.smallD[OF assms(2) zero_less_one]
     have "eventually (\<lambda>x. norm (f2 x) \<le> norm (f1 x)) F" by simp
   thus "eventually (\<lambda>x. f1 x + f2 x = f1 x * (1 + f2 x / f1 x)) F"
     by eventually_elim (auto simp: field_simps)
 next
   from assms(1) show "((\<lambda>x. f1 x * (1 + f2 x / f1 x)) \<longlongrightarrow> a) F"
     by (force intro: tendsto_eq_intros smalloD_tendsto[OF assms(2)])
 qed
 
 lemma tendsto_diff_smallo:
   shows "(f1 \<longlongrightarrow> a) F \<Longrightarrow> f2 \<in> o[F](f1) \<Longrightarrow> ((\<lambda>x. f1 x - f2 x) \<longlongrightarrow> a) F"
   using tendsto_add_smallo[of f1 a F "\<lambda>x. -f2 x"] by simp
 
 lemma tendsto_add_smallo_iff:
   assumes "f2 \<in> o[F](f1)"
   shows   "(f1 \<longlongrightarrow> a) F \<longleftrightarrow> ((\<lambda>x. f1 x + f2 x) \<longlongrightarrow> a) F"
 proof
   assume "((\<lambda>x. f1 x + f2 x) \<longlongrightarrow> a) F"
   hence "((\<lambda>x. f1 x + f2 x - f2 x) \<longlongrightarrow> a) F"
     by (rule tendsto_diff_smallo) (simp add: landau_o.small.plus_absorb2 assms)
   thus "(f1 \<longlongrightarrow> a) F" by simp
 qed (rule tendsto_add_smallo[OF _ assms])
 
 lemma tendsto_diff_smallo_iff:
   shows "f2 \<in> o[F](f1) \<Longrightarrow> (f1 \<longlongrightarrow> a) F \<longleftrightarrow> ((\<lambda>x. f1 x - f2 x) \<longlongrightarrow> a) F"
   using tendsto_add_smallo_iff[of "\<lambda>x. -f2 x" F f1 a] by simp
 
 lemma tendsto_divide_smallo:
   assumes "((\<lambda>x. f1 x / g1 x) \<longlongrightarrow> a) F"
   assumes "f2 \<in> o[F](f1)" "g2 \<in> o[F](g1)"
   assumes "eventually (\<lambda>x. g1 x \<noteq> 0) F"
   shows   "((\<lambda>x. (f1 x + f2 x) / (g1 x + g2 x)) \<longlongrightarrow> a) F" (is "(?f \<longlongrightarrow> _) _")
 proof (subst tendsto_cong)
   let ?f' = "\<lambda>x. (f1 x / g1 x) * (1 + f2 x / f1 x) / (1 + g2 x / g1 x)"
 
   have "(?f' \<longlongrightarrow> a * (1 + 0) / (1 + 0)) F"
-  by (rule tendsto_mult tendsto_divide tendsto_add assms tendsto_const 
+  by (rule tendsto_mult tendsto_divide tendsto_add assms tendsto_const
         smalloD_tendsto[OF assms(2)] smalloD_tendsto[OF assms(3)])+ simp_all
   thus "(?f' \<longlongrightarrow> a) F" by simp
 
   have "(1/2::real) > 0" by simp
   from landau_o.smallD[OF assms(2) this] landau_o.smallD[OF assms(3) this]
     have "eventually (\<lambda>x. norm (f2 x) \<le> norm (f1 x)/2) F"
          "eventually (\<lambda>x. norm (g2 x) \<le> norm (g1 x)/2) F" by simp_all
   with assms(4) show "eventually (\<lambda>x. ?f x = ?f' x) F"
   proof eventually_elim
-    fix x assume A: "norm (f2 x) \<le> norm (f1 x)/2" and 
+    fix x assume A: "norm (f2 x) \<le> norm (f1 x)/2" and
                  B: "norm (g2 x) \<le> norm (g1 x)/2" and C: "g1 x \<noteq> 0"
     show "?f x = ?f' x"
     proof (cases "f1 x = 0")
       assume D: "f1 x \<noteq> 0"
       from D have "f1 x + f2 x = f1 x * (1 + f2 x/f1 x)" by (simp add: field_simps)
       moreover from C have "g1 x + g2 x = g1 x * (1 + g2 x/g1 x)" by (simp add: field_simps)
       ultimately have "?f x = (f1 x * (1 + f2 x/f1 x)) / (g1 x * (1 + g2 x/g1 x))" by (simp only:)
       also have "... = ?f' x" by simp
       finally show ?thesis .
     qed (insert A, simp)
   qed
 qed
 
 
 lemma bigo_powr:
   fixes f :: "'a \<Rightarrow> real"
   assumes "f \<in> O[F](g)" "p \<ge> 0"
   shows   "(\<lambda>x. \<bar>f x\<bar> powr p) \<in> O[F](\<lambda>x. \<bar>g x\<bar> powr p)"
 proof-
-  from assms(1) guess c by (elim landau_o.bigE landau_omega.bigE IntE)
-  note c = this
-  from c(2) assms(2) have "eventually (\<lambda>x. (norm (f x)) powr p \<le> (c * (norm (g x))) powr p) F"
+  from assms(1) obtain c where c: "c > 0" and *: "\<forall>\<^sub>F x in F. norm (f x) \<le> c * norm (g x)"
+    by (elim landau_o.bigE landau_omega.bigE IntE)
+  from assms(2) * have "eventually (\<lambda>x. (norm (f x)) powr p \<le> (c * norm (g x)) powr p) F"
     by (auto elim!: eventually_mono intro!: powr_mono2)
-  thus "(\<lambda>x. \<bar>f x\<bar> powr p) \<in> O[F](\<lambda>x. \<bar>g x\<bar> powr p)" using c(1)
+  with c show "(\<lambda>x. \<bar>f x\<bar> powr p) \<in> O[F](\<lambda>x. \<bar>g x\<bar> powr p)"
     by (intro bigoI[of _ "c powr p"]) (simp_all add: powr_mult)
 qed
 
 lemma smallo_powr:
   fixes f :: "'a \<Rightarrow> real"
   assumes "f \<in> o[F](g)" "p > 0"
   shows   "(\<lambda>x. \<bar>f x\<bar> powr p) \<in> o[F](\<lambda>x. \<bar>g x\<bar> powr p)"
 proof (rule landau_o.smallI)
   fix c :: real assume c: "c > 0"
   hence "c powr (1/p) > 0" by simp
-  from landau_o.smallD[OF assms(1) this] 
+  from landau_o.smallD[OF assms(1) this]
   show "eventually (\<lambda>x. norm (\<bar>f x\<bar> powr p) \<le> c * norm (\<bar>g x\<bar> powr p)) F"
   proof eventually_elim
     fix x assume "(norm (f x)) \<le> c powr (1 / p) * (norm (g x))"
     with assms(2) have "(norm (f x)) powr p \<le> (c powr (1 / p) * (norm (g x))) powr p"
       by (intro powr_mono2) simp_all
     also from assms(2) c have "... = c * (norm (g x)) powr p"
       by (simp add: field_simps powr_mult powr_powr)
     finally show "norm (\<bar>f x\<bar> powr p) \<le> c * norm (\<bar>g x\<bar> powr p)" by simp
   qed
 qed
 
 lemma smallo_powr_nonneg:
   fixes f :: "'a \<Rightarrow> real"
   assumes "f \<in> o[F](g)" "p > 0" "eventually (\<lambda>x. f x \<ge> 0) F" "eventually (\<lambda>x. g x \<ge> 0) F"
   shows   "(\<lambda>x. f x powr p) \<in> o[F](\<lambda>x. g x powr p)"
 proof -
-  from assms(3) have "(\<lambda>x. f x powr p) \<in> \<Theta>[F](\<lambda>x. \<bar>f x\<bar> powr p)" 
+  from assms(3) have "(\<lambda>x. f x powr p) \<in> \<Theta>[F](\<lambda>x. \<bar>f x\<bar> powr p)"
     by (intro bigthetaI_cong) (auto elim!: eventually_mono)
   also have "(\<lambda>x. \<bar>f x\<bar> powr p) \<in> o[F](\<lambda>x. \<bar>g x\<bar> powr p)" by (intro smallo_powr) fact+
   also from assms(4) have "(\<lambda>x. \<bar>g x\<bar> powr p) \<in> \<Theta>[F](\<lambda>x. g x powr p)"
     by (intro bigthetaI_cong) (auto elim!: eventually_mono)
   finally show ?thesis .
 qed
 
 lemma bigtheta_powr:
   fixes f :: "'a \<Rightarrow> real"
   shows "f \<in> \<Theta>[F](g) \<Longrightarrow> (\<lambda>x. \<bar>f x\<bar> powr p) \<in> \<Theta>[F](\<lambda>x. \<bar>g x\<bar> powr p)"
 apply (cases "p < 0")
 apply (subst bigtheta_inverse[symmetric], subst (1 2) powr_minus[symmetric])
 unfolding bigtheta_def apply (auto simp: bigomega_iff_bigo intro!: bigo_powr)
 done
 
 lemma bigo_powr_nonneg:
   fixes f :: "'a \<Rightarrow> real"
   assumes "f \<in> O[F](g)" "p \<ge> 0" "eventually (\<lambda>x. f x \<ge> 0) F" "eventually (\<lambda>x. g x \<ge> 0) F"
   shows   "(\<lambda>x. f x powr p) \<in> O[F](\<lambda>x. g x powr p)"
 proof -
-  from assms(3) have "(\<lambda>x. f x powr p) \<in> \<Theta>[F](\<lambda>x. \<bar>f x\<bar> powr p)" 
+  from assms(3) have "(\<lambda>x. f x powr p) \<in> \<Theta>[F](\<lambda>x. \<bar>f x\<bar> powr p)"
     by (intro bigthetaI_cong) (auto elim!: eventually_mono)
   also have "(\<lambda>x. \<bar>f x\<bar> powr p) \<in> O[F](\<lambda>x. \<bar>g x\<bar> powr p)" by (intro bigo_powr) fact+
   also from assms(4) have "(\<lambda>x. \<bar>g x\<bar> powr p) \<in> \<Theta>[F](\<lambda>x. g x powr p)"
     by (intro bigthetaI_cong) (auto elim!: eventually_mono)
   finally show ?thesis .
 qed
 
 lemma zero_in_smallo [simp]: "(\<lambda>_. 0) \<in> o[F](f)"
   by (intro landau_o.smallI) simp_all
 
 lemma zero_in_bigo [simp]: "(\<lambda>_. 0) \<in> O[F](f)"
   by (intro landau_o.bigI[of 1]) simp_all
 
 lemma in_bigomega_zero [simp]: "f \<in> \<Omega>[F](\<lambda>x. 0)"
   by (rule landau_omega.bigI[of 1]) simp_all
 
 lemma in_smallomega_zero [simp]: "f \<in> \<omega>[F](\<lambda>x. 0)"
   by (simp add: smallomega_iff_smallo)
 
 
 lemma in_smallo_zero_iff [simp]: "f \<in> o[F](\<lambda>_. 0) \<longleftrightarrow> eventually (\<lambda>x. f x = 0) F"
 proof
   assume "f \<in> o[F](\<lambda>_. 0)"
   from landau_o.smallD[OF this, of 1] show "eventually (\<lambda>x. f x = 0) F" by simp
 next
   assume "eventually (\<lambda>x. f x = 0) F"
   hence "\<forall>c>0. eventually (\<lambda>x. (norm (f x)) \<le> c * \<bar>0\<bar>) F" by simp
   thus "f \<in> o[F](\<lambda>_. 0)" unfolding smallo_def by simp
 qed
 
 lemma in_bigo_zero_iff [simp]: "f \<in> O[F](\<lambda>_. 0) \<longleftrightarrow> eventually (\<lambda>x. f x = 0) F"
 proof
   assume "f \<in> O[F](\<lambda>_. 0)"
   thus "eventually (\<lambda>x. f x = 0) F" by (elim landau_o.bigE) simp
 next
   assume "eventually (\<lambda>x. f x = 0) F"
   hence "eventually (\<lambda>x. (norm (f x)) \<le> 1 * \<bar>0\<bar>) F" by simp
   thus "f \<in> O[F](\<lambda>_. 0)" by (intro landau_o.bigI[of 1]) simp_all
 qed
 
 lemma zero_in_smallomega_iff [simp]: "(\<lambda>_. 0) \<in> \<omega>[F](f) \<longleftrightarrow> eventually (\<lambda>x. f x = 0) F"
   by (simp add: smallomega_iff_smallo)
 
 lemma zero_in_bigomega_iff [simp]: "(\<lambda>_. 0) \<in> \<Omega>[F](f) \<longleftrightarrow> eventually (\<lambda>x. f x = 0) F"
   by (simp add: bigomega_iff_bigo)
 
 lemma zero_in_bigtheta_iff [simp]: "(\<lambda>_. 0) \<in> \<Theta>[F](f) \<longleftrightarrow> eventually (\<lambda>x. f x = 0) F"
   unfolding bigtheta_def by simp
 
 lemma in_bigtheta_zero_iff [simp]: "f \<in> \<Theta>[F](\<lambda>x. 0) \<longleftrightarrow> eventually (\<lambda>x. f x = 0) F"
   unfolding bigtheta_def by simp
 
 
 lemma cmult_in_bigo_iff    [simp]:  "(\<lambda>x. c * f x) \<in> O[F](g) \<longleftrightarrow> c = 0 \<or> f \<in> O[F](g)"
   and cmult_in_bigo_iff'   [simp]:  "(\<lambda>x. f x * c) \<in> O[F](g) \<longleftrightarrow> c = 0 \<or> f \<in> O[F](g)"
   and cmult_in_smallo_iff  [simp]:  "(\<lambda>x. c * f x) \<in> o[F](g) \<longleftrightarrow> c = 0 \<or> f \<in> o[F](g)"
   and cmult_in_smallo_iff' [simp]: "(\<lambda>x. f x * c) \<in> o[F](g) \<longleftrightarrow> c = 0 \<or> f \<in> o[F](g)"
   by (cases "c = 0", simp, simp)+
 
 lemma bigo_const [simp]: "(\<lambda>_. c) \<in> O[F](\<lambda>_. 1)" by (rule bigoI[of _ "norm c"]) simp
 
 lemma bigo_const_iff [simp]: "(\<lambda>_. c1) \<in> O[F](\<lambda>_. c2) \<longleftrightarrow> F = bot \<or> c1 = 0 \<or> c2 \<noteq> 0"
   by (cases "c1 = 0"; cases "c2 = 0")
      (auto simp: bigo_def eventually_False intro: exI[of _ 1] exI[of _ "norm c1 / norm c2"])
 
 lemma bigomega_const_iff [simp]: "(\<lambda>_. c1) \<in> \<Omega>[F](\<lambda>_. c2) \<longleftrightarrow> F = bot \<or> c1 \<noteq> 0 \<or> c2 = 0"
   by (cases "c1 = 0"; cases "c2 = 0")
-     (auto simp: bigomega_def eventually_False mult_le_0_iff 
+     (auto simp: bigomega_def eventually_False mult_le_0_iff
            intro: exI[of _ 1] exI[of _ "norm c1 / norm c2"])
 
 lemma smallo_real_nat_transfer:
   "(f :: real \<Rightarrow> real) \<in> o(g) \<Longrightarrow> (\<lambda>x::nat. f (real x)) \<in> o(\<lambda>x. g (real x))"
   by (rule landau_o.small.compose[OF _ filterlim_real_sequentially])
 
 lemma bigo_real_nat_transfer:
   "(f :: real \<Rightarrow> real) \<in> O(g) \<Longrightarrow> (\<lambda>x::nat. f (real x)) \<in> O(\<lambda>x. g (real x))"
   by (rule landau_o.big.compose[OF _ filterlim_real_sequentially])
 
 lemma smallomega_real_nat_transfer:
   "(f :: real \<Rightarrow> real) \<in> \<omega>(g) \<Longrightarrow> (\<lambda>x::nat. f (real x)) \<in> \<omega>(\<lambda>x. g (real x))"
   by (rule landau_omega.small.compose[OF _ filterlim_real_sequentially])
 
 lemma bigomega_real_nat_transfer:
   "(f :: real \<Rightarrow> real) \<in> \<Omega>(g) \<Longrightarrow> (\<lambda>x::nat. f (real x)) \<in> \<Omega>(\<lambda>x. g (real x))"
   by (rule landau_omega.big.compose[OF _ filterlim_real_sequentially])
 
 lemma bigtheta_real_nat_transfer:
   "(f :: real \<Rightarrow> real) \<in> \<Theta>(g) \<Longrightarrow> (\<lambda>x::nat. f (real x)) \<in> \<Theta>(\<lambda>x. g (real x))"
   unfolding bigtheta_def using bigo_real_nat_transfer bigomega_real_nat_transfer by blast
 
-lemmas landau_real_nat_transfer [intro] = 
-  bigo_real_nat_transfer smallo_real_nat_transfer bigomega_real_nat_transfer 
+lemmas landau_real_nat_transfer [intro] =
+  bigo_real_nat_transfer smallo_real_nat_transfer bigomega_real_nat_transfer
   smallomega_real_nat_transfer bigtheta_real_nat_transfer
 
 
 lemma landau_symbol_if_at_top_eq [simp]:
   assumes "landau_symbol L L' Lr"
   shows   "L at_top (\<lambda>x::'a::linordered_semidom. if x = a then f x else g x) = L at_top (g)"
 apply (rule landau_symbol.cong[OF assms])
 using less_add_one[of a] apply (auto intro: eventually_mono  eventually_ge_at_top[of "a + 1"])
 done
 
 lemmas landau_symbols_if_at_top_eq [simp] = landau_symbols[THEN landau_symbol_if_at_top_eq]
 
 
 
 lemma sum_in_smallo:
   assumes "f \<in> o[F](h)" "g \<in> o[F](h)"
   shows   "(\<lambda>x. f x + g x) \<in> o[F](h)" "(\<lambda>x. f x - g x) \<in> o[F](h)"
-proof-
-  {
-    fix f g assume fg: "f \<in> o[F](h)" "g \<in> o[F](h)"
-    have "(\<lambda>x. f x + g x) \<in> o[F](h)"
-    proof (rule landau_o.smallI)
-      fix c :: real assume "c > 0"
-      hence "c/2 > 0" by simp
-      from fg[THEN landau_o.smallD[OF _ this]]
-      show "eventually (\<lambda>x. norm (f x + g x) \<le> c * (norm (h x))) F"
-        by eventually_elim (auto intro: order.trans[OF norm_triangle_ineq])
-    qed
-  }
+proof -
+  have "(\<lambda>x. f x + g x) \<in> o[F](h)" if "f \<in> o[F](h)" "g \<in> o[F](h)" for f g
+  proof (rule landau_o.smallI)
+    fix c :: real assume "c > 0"
+    hence "c/2 > 0" by simp
+    from that[THEN landau_o.smallD[OF _ this]]
+    show "eventually (\<lambda>x. norm (f x + g x) \<le> c * (norm (h x))) F"
+      by eventually_elim (auto intro: order.trans[OF norm_triangle_ineq])
+  qed
   from this[of f g] this[of f "\<lambda>x. -g x"] assms
     show "(\<lambda>x. f x + g x) \<in> o[F](h)" "(\<lambda>x. f x - g x) \<in> o[F](h)" by simp_all
 qed
 
 lemma big_sum_in_smallo:
   assumes "\<And>x. x \<in> A \<Longrightarrow> f x \<in> o[F](g)"
   shows   "(\<lambda>x. sum (\<lambda>y. f y x) A) \<in> o[F](g)"
   using assms by (induction A rule: infinite_finite_induct) (auto intro: sum_in_smallo)
 
 lemma sum_in_bigo:
   assumes "f \<in> O[F](h)" "g \<in> O[F](h)"
   shows   "(\<lambda>x. f x + g x) \<in> O[F](h)" "(\<lambda>x. f x - g x) \<in> O[F](h)"
-proof-
-  {
-    fix f g assume fg: "f \<in> O[F](h)" "g \<in> O[F](h)"
-    from fg(1) guess c1 by (elim landau_o.bigE) note c1 = this
-    from fg(2) guess c2 by (elim landau_o.bigE) note c2 = this
-    from c1(2) c2(2) have "eventually (\<lambda>x. norm (f x + g x) \<le> (c1 + c2) * (norm (h x))) F"
+proof -
+  have "(\<lambda>x. f x + g x) \<in> O[F](h)" if "f \<in> O[F](h)" "g \<in> O[F](h)" for f g
+  proof -
+    from that obtain c1 c2 where *: "c1 > 0" "c2 > 0"
+      and **: "\<forall>\<^sub>F x in F. norm (f x) \<le> c1 * norm (h x)"
+              "\<forall>\<^sub>F x in F. norm (g x) \<le> c2 * norm (h x)"
+      by (elim landau_o.bigE)
+    from ** have "eventually (\<lambda>x. norm (f x + g x) \<le> (c1 + c2) * (norm (h x))) F"
       by eventually_elim (auto simp: algebra_simps intro: order.trans[OF norm_triangle_ineq])
-    hence "(\<lambda>x. f x + g x) \<in> O[F](h)" by (rule bigoI)
-  }
-  from this[of f g] this[of f "\<lambda>x. -g x"] assms
-    show "(\<lambda>x. f x + g x) \<in> O[F](h)" "(\<lambda>x. f x - g x) \<in> O[F](h)" by simp_all
+    then show ?thesis by (rule bigoI)
+  qed
+  from assms this[of f g] this[of f "\<lambda>x. - g x"]
+  show "(\<lambda>x. f x + g x) \<in> O[F](h)" "(\<lambda>x. f x - g x) \<in> O[F](h)" by simp_all
 qed
 
 lemma big_sum_in_bigo:
   assumes "\<And>x. x \<in> A \<Longrightarrow> f x \<in> O[F](g)"
   shows   "(\<lambda>x. sum (\<lambda>y. f y x) A) \<in> O[F](g)"
   using assms by (induction A rule: infinite_finite_induct) (auto intro: sum_in_bigo)
 
 context landau_symbol
 begin
 
 lemma mult_cancel_left:
   assumes "f1 \<in> \<Theta>[F](g1)" and "eventually (\<lambda>x. g1 x \<noteq> 0) F"
   notes   [trans] = bigtheta_trans1 bigtheta_trans2
   shows   "(\<lambda>x. f1 x * f2 x) \<in> L F (\<lambda>x. g1 x * g2 x) \<longleftrightarrow> f2 \<in> L F (g2)"
 proof
   assume A: "(\<lambda>x. f1 x * f2 x) \<in> L F (\<lambda>x. g1 x * g2 x)"
   from assms have nz: "eventually (\<lambda>x. f1 x \<noteq> 0) F" by (simp add: eventually_nonzero_bigtheta)
   hence "f2 \<in> \<Theta>[F](\<lambda>x. f1 x * f2 x / f1 x)"
     by (intro bigthetaI_cong) (auto elim!: eventually_mono)
-  also from A assms nz have "(\<lambda>x. f1 x * f2 x / f1 x) \<in> L F (\<lambda>x. g1 x * g2 x / f1 x)" 
+  also from A assms nz have "(\<lambda>x. f1 x * f2 x / f1 x) \<in> L F (\<lambda>x. g1 x * g2 x / f1 x)"
     by (intro divide_right) simp_all
   also from assms nz have "(\<lambda>x. g1 x * g2 x / f1 x) \<in> \<Theta>[F](\<lambda>x. g1 x * g2 x / g1 x)"
     by (intro landau_theta.mult landau_theta.divide) (simp_all add: bigtheta_sym)
   also from assms have "(\<lambda>x. g1 x * g2 x / g1 x) \<in> \<Theta>[F](g2)"
     by (intro bigthetaI_cong) (auto elim!: eventually_mono)
   finally show "f2 \<in> L F (g2)" .
 next
   assume "f2 \<in> L F (g2)"
   hence "(\<lambda>x. f1 x * f2 x) \<in> L F (\<lambda>x. f1 x * g2 x)" by (rule mult_left)
   also have "(\<lambda>x. f1 x * g2 x) \<in> \<Theta>[F](\<lambda>x. g1 x * g2 x)"
     by (intro landau_theta.mult_right assms)
   finally show "(\<lambda>x. f1 x * f2 x) \<in> L F (\<lambda>x. g1 x * g2 x)" .
 qed
 
 lemma mult_cancel_right:
   assumes "f2 \<in> \<Theta>[F](g2)" and "eventually (\<lambda>x. g2 x \<noteq> 0) F"
   shows   "(\<lambda>x. f1 x * f2 x) \<in> L F (\<lambda>x. g1 x * g2 x) \<longleftrightarrow> f1 \<in> L F (g1)"
   by (subst (1 2) mult.commute) (rule mult_cancel_left[OF assms])
 
 lemma divide_cancel_right:
   assumes "f2 \<in> \<Theta>[F](g2)" and "eventually (\<lambda>x. g2 x \<noteq> 0) F"
   shows   "(\<lambda>x. f1 x / f2 x) \<in> L F (\<lambda>x. g1 x / g2 x) \<longleftrightarrow> f1 \<in> L F (g1)"
   by (subst (1 2) divide_inverse, intro mult_cancel_right bigtheta_inverse) (simp_all add: assms)
 
 lemma divide_cancel_left:
   assumes "f1 \<in> \<Theta>[F](g1)" and "eventually (\<lambda>x. g1 x \<noteq> 0) F"
-  shows   "(\<lambda>x. f1 x / f2 x) \<in> L F (\<lambda>x. g1 x / g2 x) \<longleftrightarrow> 
+  shows   "(\<lambda>x. f1 x / f2 x) \<in> L F (\<lambda>x. g1 x / g2 x) \<longleftrightarrow>
              (\<lambda>x. inverse (f2 x)) \<in> L F (\<lambda>x. inverse (g2 x))"
   by (simp only: divide_inverse mult_cancel_left[OF assms])
 
 end
 
 
 lemma powr_smallo_iff:
   assumes "filterlim g at_top F" "F \<noteq> bot"
   shows   "(\<lambda>x. g x powr p :: real) \<in> o[F](\<lambda>x. g x powr q) \<longleftrightarrow> p < q"
 proof-
   from assms have "eventually (\<lambda>x. g x \<ge> 1) F" by (force simp: filterlim_at_top)
   hence A: "eventually (\<lambda>x. g x \<noteq> 0) F" by eventually_elim simp
   have B: "(\<lambda>x. g x powr q) \<in> O[F](\<lambda>x. g x powr p) \<Longrightarrow> (\<lambda>x. g x powr p) \<notin> o[F](\<lambda>x. g x powr q)"
   proof
     assume "(\<lambda>x. g x powr q) \<in> O[F](\<lambda>x. g x powr p)" "(\<lambda>x. g x powr p) \<in> o[F](\<lambda>x. g x powr q)"
     from landau_o.big_small_asymmetric[OF this] have "eventually (\<lambda>x. g x = 0) F" by simp
     with A have "eventually (\<lambda>_::'a. False) F" by eventually_elim simp
     thus False by (simp add: eventually_False assms)
   qed
   show ?thesis
   proof (cases p q rule: linorder_cases)
     assume "p < q"
     hence "(\<lambda>x. g x powr p) \<in> o[F](\<lambda>x. g x powr q)" using assms A
       by (auto intro!: smalloI_tendsto tendsto_neg_powr simp flip: powr_diff)
     with \<open>p < q\<close> show ?thesis by auto
   next
     assume "p = q"
     hence "(\<lambda>x. g x powr q) \<in> O[F](\<lambda>x. g x powr p)" by (auto intro!: bigthetaD1)
     with B \<open>p = q\<close> show ?thesis by auto
   next
     assume "p > q"
     hence "(\<lambda>x. g x powr q) \<in> O[F](\<lambda>x. g x powr p)" using assms A
       by (auto intro!: smalloI_tendsto tendsto_neg_powr landau_o.small_imp_big simp flip: powr_diff)
     with B \<open>p > q\<close> show ?thesis by auto
   qed
 qed
 
 lemma powr_bigo_iff:
   assumes "filterlim g at_top F" "F \<noteq> bot"
   shows   "(\<lambda>x. g x powr p :: real) \<in> O[F](\<lambda>x. g x powr q) \<longleftrightarrow> p \<le> q"
 proof-
   from assms have "eventually (\<lambda>x. g x \<ge> 1) F" by (force simp: filterlim_at_top)
   hence A: "eventually (\<lambda>x. g x \<noteq> 0) F" by eventually_elim simp
   have B: "(\<lambda>x. g x powr q) \<in> o[F](\<lambda>x. g x powr p) \<Longrightarrow> (\<lambda>x. g x powr p) \<notin> O[F](\<lambda>x. g x powr q)"
   proof
     assume "(\<lambda>x. g x powr q) \<in> o[F](\<lambda>x. g x powr p)" "(\<lambda>x. g x powr p) \<in> O[F](\<lambda>x. g x powr q)"
     from landau_o.small_big_asymmetric[OF this] have "eventually (\<lambda>x. g x = 0) F" by simp
     with A have "eventually (\<lambda>_::'a. False) F" by eventually_elim simp
     thus False by (simp add: eventually_False assms)
   qed
   show ?thesis
   proof (cases p q rule: linorder_cases)
     assume "p < q"
     hence "(\<lambda>x. g x powr p) \<in> o[F](\<lambda>x. g x powr q)" using assms A
       by (auto intro!: smalloI_tendsto tendsto_neg_powr simp flip: powr_diff)
     with \<open>p < q\<close> show ?thesis by (auto intro: landau_o.small_imp_big)
   next
     assume "p = q"
     hence "(\<lambda>x. g x powr q) \<in> O[F](\<lambda>x. g x powr p)" by (auto intro!: bigthetaD1)
     with B \<open>p = q\<close> show ?thesis by auto
   next
     assume "p > q"
     hence "(\<lambda>x. g x powr q) \<in> o[F](\<lambda>x. g x powr p)" using assms A
       by (auto intro!: smalloI_tendsto tendsto_neg_powr simp flip: powr_diff)
     with B \<open>p > q\<close> show ?thesis by (auto intro: landau_o.small_imp_big)
   qed
 qed
 
-lemma powr_bigtheta_iff: 
+lemma powr_bigtheta_iff:
   assumes "filterlim g at_top F" "F \<noteq> bot"
   shows   "(\<lambda>x. g x powr p :: real) \<in> \<Theta>[F](\<lambda>x. g x powr q) \<longleftrightarrow> p = q"
   using assms unfolding bigtheta_def by (auto simp: bigomega_iff_bigo powr_bigo_iff)
 
 
 subsection \<open>Flatness of real functions\<close>
 
 text \<open>
   Given two real-valued functions $f$ and $g$, we say that $f$ is flatter than $g$ if
   any power of $f(x)$ is asymptotically dominated by any positive power of $g(x)$. This is
   a useful notion since, given two products of powers of functions sorted by flatness, we can
   compare them asymptotically by simply comparing the exponent lists lexicographically.
 
   A simple sufficient criterion for flatness it that $\ln f(x) \in o(\ln g(x))$, which we show
   now.
 \<close>
 lemma ln_smallo_imp_flat:
   fixes f g :: "real \<Rightarrow> real"
   assumes lim_f: "filterlim f at_top at_top"
   assumes lim_g: "filterlim g at_top at_top"
   assumes ln_o_ln: "(\<lambda>x. ln (f x)) \<in> o(\<lambda>x. ln (g x))"
   assumes q: "q > 0"
   shows   "(\<lambda>x. f x powr p) \<in> o(\<lambda>x. g x powr q)"
 proof (rule smalloI_tendsto)
-  from lim_f have "eventually (\<lambda>x. f x > 0) at_top" 
+  from lim_f have "eventually (\<lambda>x. f x > 0) at_top"
     by (simp add: filterlim_at_top_dense)
   hence f_nz: "eventually (\<lambda>x. f x \<noteq> 0) at_top" by eventually_elim simp
-  
+
   from lim_g have g_gt_1: "eventually (\<lambda>x. g x > 1) at_top"
     by (simp add: filterlim_at_top_dense)
   hence g_nz: "eventually (\<lambda>x. g x \<noteq> 0) at_top" by eventually_elim simp
   thus "eventually (\<lambda>x. g x powr q \<noteq> 0) at_top"
     by eventually_elim simp
-  
-  have eq: "eventually (\<lambda>x. q * (p/q * (ln (f x) / ln (g x)) - 1) * ln (g x) = 
+
+  have eq: "eventually (\<lambda>x. q * (p/q * (ln (f x) / ln (g x)) - 1) * ln (g x) =
                           p * ln (f x) - q * ln (g x)) at_top"
     using g_gt_1 by eventually_elim (insert q, simp_all add: field_simps)
   have "filterlim (\<lambda>x. q * (p/q * (ln (f x) / ln (g x)) - 1) * ln (g x)) at_bot at_top"
     by (insert q)
        (rule filterlim_tendsto_neg_mult_at_bot tendsto_mult
               tendsto_const tendsto_diff smalloD_tendsto[OF ln_o_ln] lim_g
               filterlim_compose[OF ln_at_top] | simp)+
   hence "filterlim (\<lambda>x. p * ln (f x) - q * ln (g x)) at_bot at_top"
     by (subst (asm) filterlim_cong[OF refl refl eq])
   hence *: "((\<lambda>x. exp (p * ln (f x) - q * ln (g x))) \<longlongrightarrow> 0) at_top"
     by (rule filterlim_compose[OF exp_at_bot])
   have eq: "eventually (\<lambda>x. exp (p * ln (f x) - q * ln (g x)) = f x powr p / g x powr q) at_top"
     using f_nz g_nz by eventually_elim (simp add: powr_def exp_diff)
   show "((\<lambda>x. f x powr p / g x powr q) \<longlongrightarrow> 0) at_top"
     using * by (subst (asm) filterlim_cong[OF refl refl eq])
 qed
 
 lemma ln_smallo_imp_flat':
   fixes f g :: "real \<Rightarrow> real"
   assumes lim_f: "filterlim f at_top at_top"
   assumes lim_g: "filterlim g at_top at_top"
   assumes ln_o_ln: "(\<lambda>x. ln (f x)) \<in> o(\<lambda>x. ln (g x))"
   assumes q: "q < 0"
   shows   "(\<lambda>x. g x powr q) \<in> o(\<lambda>x. f x powr p)"
 proof -
   from lim_f lim_g have "eventually (\<lambda>x. f x > 0) at_top" "eventually (\<lambda>x. g x > 0) at_top"
     by (simp_all add: filterlim_at_top_dense)
   hence "eventually (\<lambda>x. f x \<noteq> 0) at_top" "eventually (\<lambda>x. g x \<noteq> 0) at_top"
     by (auto elim: eventually_mono)
   moreover from assms have "(\<lambda>x. f x powr -p) \<in> o(\<lambda>x. g x powr -q)"
     by (intro ln_smallo_imp_flat assms) simp_all
   ultimately show ?thesis unfolding powr_minus
     by (simp add: landau_o.small.inverse_cancel)
 qed
 
 
 subsection \<open>Asymptotic Equivalence\<close>
 
 named_theorems asymp_equiv_intros
 named_theorems asymp_equiv_simps
 
 definition asymp_equiv :: "('a \<Rightarrow> ('b :: real_normed_field)) \<Rightarrow> 'a filter \<Rightarrow> ('a \<Rightarrow> 'b) \<Rightarrow> bool"
   (\<open>_ \<sim>[_] _\<close> [51, 10, 51] 50)
   where "f \<sim>[F] g \<longleftrightarrow> ((\<lambda>x. if f x = 0 \<and> g x = 0 then 1 else f x / g x) \<longlongrightarrow> 1) F"
 
 abbreviation (input) asymp_equiv_at_top where
   "asymp_equiv_at_top f g \<equiv> f \<sim>[at_top] g"
 
 bundle asymp_equiv_notation
 begin
-notation asymp_equiv_at_top (infix \<open>\<sim>\<close> 50) 
+notation asymp_equiv_at_top (infix \<open>\<sim>\<close> 50)
 end
 
 lemma asymp_equivI: "((\<lambda>x. if f x = 0 \<and> g x = 0 then 1 else f x / g x) \<longlongrightarrow> 1) F \<Longrightarrow> f \<sim>[F] g"
   by (simp add: asymp_equiv_def)
 
 lemma asymp_equivD: "f \<sim>[F] g \<Longrightarrow> ((\<lambda>x. if f x = 0 \<and> g x = 0 then 1 else f x / g x) \<longlongrightarrow> 1) F"
   by (simp add: asymp_equiv_def)
 
 lemma asymp_equiv_filtermap_iff:
   "f \<sim>[filtermap h F] g \<longleftrightarrow> (\<lambda>x. f (h x)) \<sim>[F] (\<lambda>x. g (h x))"
   by (simp add: asymp_equiv_def filterlim_filtermap)
 
 lemma asymp_equiv_refl [simp, asymp_equiv_intros]: "f \<sim>[F] f"
 proof (intro asymp_equivI)
   have "eventually (\<lambda>x. 1 = (if f x = 0 \<and> f x = 0 then 1 else f x / f x)) F"
     by (intro always_eventually) simp
   moreover have "((\<lambda>_. 1) \<longlongrightarrow> 1) F" by simp
   ultimately show "((\<lambda>x. if f x = 0 \<and> f x = 0 then 1 else f x / f x) \<longlongrightarrow> 1) F"
     by (simp add: tendsto_eventually)
 qed
 
-lemma asymp_equiv_symI: 
+lemma asymp_equiv_symI:
   assumes "f \<sim>[F] g"
   shows   "g \<sim>[F] f"
   using tendsto_inverse[OF asymp_equivD[OF assms]]
   by (auto intro!: asymp_equivI simp: if_distrib conj_commute cong: if_cong)
 
 lemma asymp_equiv_sym: "f \<sim>[F] g \<longleftrightarrow> g \<sim>[F] f"
   by (blast intro: asymp_equiv_symI)
 
-lemma asymp_equivI': 
+lemma asymp_equivI':
   assumes "((\<lambda>x. f x / g x) \<longlongrightarrow> 1) F"
   shows   "f \<sim>[F] g"
 proof (cases "F = bot")
   case False
   have "eventually (\<lambda>x. f x \<noteq> 0) F"
   proof (rule ccontr)
     assume "\<not>eventually (\<lambda>x. f x \<noteq> 0) F"
     hence "frequently (\<lambda>x. f x = 0) F" by (simp add: frequently_def)
     hence "frequently (\<lambda>x. f x / g x = 0) F" by (auto elim!: frequently_elim1)
     from limit_frequently_eq[OF False this assms] show False by simp_all
   qed
   hence "eventually (\<lambda>x. f x / g x = (if f x = 0 \<and> g x = 0 then 1 else f x / g x)) F"
     by eventually_elim simp
-  with assms show "f \<sim>[F] g" unfolding asymp_equiv_def 
+  with assms show "f \<sim>[F] g" unfolding asymp_equiv_def
     by (rule Lim_transform_eventually)
 qed (simp_all add: asymp_equiv_def)
 
 
 lemma asymp_equiv_cong:
   assumes "eventually (\<lambda>x. f1 x = f2 x) F" "eventually (\<lambda>x. g1 x = g2 x) F"
   shows   "f1 \<sim>[F] g1 \<longleftrightarrow> f2 \<sim>[F] g2"
   unfolding asymp_equiv_def
 proof (rule tendsto_cong, goal_cases)
   case 1
   from assms show ?case by eventually_elim simp
 qed
 
 lemma asymp_equiv_eventually_zeros:
   fixes f g :: "'a \<Rightarrow> 'b :: real_normed_field"
   assumes "f \<sim>[F] g"
   shows   "eventually (\<lambda>x. f x = 0 \<longleftrightarrow> g x = 0) F"
 proof -
   let ?h = "\<lambda>x. if f x = 0 \<and> g x = 0 then 1 else f x / g x"
   have "eventually (\<lambda>x. x \<noteq> 0) (nhds (1::'b))"
     by (rule t1_space_nhds) auto
   hence "eventually (\<lambda>x. x \<noteq> 0) (filtermap ?h F)"
     using assms unfolding asymp_equiv_def filterlim_def
     by (rule filter_leD [rotated])
   hence "eventually (\<lambda>x. ?h x \<noteq> 0) F" by (simp add: eventually_filtermap)
   thus ?thesis by eventually_elim (auto split: if_splits)
 qed
 
 lemma asymp_equiv_transfer:
   assumes "f1 \<sim>[F] g1" "eventually (\<lambda>x. f1 x = f2 x) F" "eventually (\<lambda>x. g1 x = g2 x) F"
   shows   "f2 \<sim>[F] g2"
   using assms(1) asymp_equiv_cong[OF assms(2,3)] by simp
 
 lemma asymp_equiv_transfer_trans [trans]:
   assumes "(\<lambda>x. f x (h1 x)) \<sim>[F] (\<lambda>x. g x (h1 x))"
   assumes "eventually (\<lambda>x. h1 x = h2 x) F"
   shows   "(\<lambda>x. f x (h2 x)) \<sim>[F] (\<lambda>x. g x (h2 x))"
   by (rule asymp_equiv_transfer[OF assms(1)]) (insert assms(2), auto elim!: eventually_mono)
 
 lemma asymp_equiv_trans [trans]:
   fixes f g h
   assumes "f \<sim>[F] g" "g \<sim>[F] h"
   shows   "f \<sim>[F] h"
 proof -
   let ?T = "\<lambda>f g x. if f x = 0 \<and> g x = 0 then 1 else f x / g x"
-  from tendsto_mult[OF assms[THEN asymp_equivD]] 
+  from tendsto_mult[OF assms[THEN asymp_equivD]]
   have "((\<lambda>x. ?T f g x * ?T g h x) \<longlongrightarrow> 1) F" by simp
   moreover from assms[THEN asymp_equiv_eventually_zeros]
   have "eventually (\<lambda>x. ?T f g x * ?T g h x = ?T f h x) F" by eventually_elim simp
   ultimately show ?thesis unfolding asymp_equiv_def by (rule Lim_transform_eventually)
 qed
 
 lemma asymp_equiv_trans_lift1 [trans]:
   assumes "a \<sim>[F] f b" "b \<sim>[F] c" "\<And>c d. c \<sim>[F] d \<Longrightarrow> f c \<sim>[F] f d"
   shows   "a \<sim>[F] f c"
   using assms by (blast intro: asymp_equiv_trans)
 
 lemma asymp_equiv_trans_lift2 [trans]:
   assumes "f a \<sim>[F] b" "a \<sim>[F] c" "\<And>c d. c \<sim>[F] d \<Longrightarrow> f c \<sim>[F] f d"
   shows   "f c \<sim>[F] b"
   using asymp_equiv_symI[OF assms(3)[OF assms(2)]] assms(1)
   by (blast intro: asymp_equiv_trans)
 
 lemma asymp_equivD_const:
   assumes "f \<sim>[F] (\<lambda>_. c)"
   shows   "(f \<longlongrightarrow> c) F"
 proof (cases "c = 0")
   case False
   with tendsto_mult_right[OF asymp_equivD[OF assms], of c] show ?thesis by simp
 next
   case True
   with asymp_equiv_eventually_zeros[OF assms] show ?thesis
     by (simp add: tendsto_eventually)
 qed
 
 lemma asymp_equiv_refl_ev:
   assumes "eventually (\<lambda>x. f x = g x) F"
   shows   "f \<sim>[F] g"
   by (intro asymp_equivI tendsto_eventually)
      (insert assms, auto elim!: eventually_mono)
 
 lemma asymp_equiv_sandwich:
   fixes f g h :: "'a \<Rightarrow> 'b :: {real_normed_field, order_topology, linordered_field}"
   assumes "eventually (\<lambda>x. f x \<ge> 0) F"
   assumes "eventually (\<lambda>x. f x \<le> g x) F"
   assumes "eventually (\<lambda>x. g x \<le> h x) F"
   assumes "f \<sim>[F] h"
   shows   "g \<sim>[F] f" "g \<sim>[F] h"
 proof -
   show "g \<sim>[F] f"
   proof (rule asymp_equivI, rule tendsto_sandwich)
     from assms(1-3) asymp_equiv_eventually_zeros[OF assms(4)]
       show "eventually (\<lambda>n. (if h n = 0 \<and> f n = 0 then 1 else h n / f n) \<ge>
                               (if g n = 0 \<and> f n = 0 then 1 else g n / f n)) F"
         by eventually_elim (auto intro!: divide_right_mono)
     from assms(1-3) asymp_equiv_eventually_zeros[OF assms(4)]
       show "eventually (\<lambda>n. 1 \<le>
                               (if g n = 0 \<and> f n = 0 then 1 else g n / f n)) F"
         by eventually_elim (auto intro!: divide_right_mono)
   qed (insert asymp_equiv_symI[OF assms(4)], simp_all add: asymp_equiv_def)
   also note \<open>f \<sim>[F] h\<close>
   finally show "g \<sim>[F] h" .
 qed
 
 lemma asymp_equiv_imp_eventually_same_sign:
   fixes f g :: "real \<Rightarrow> real"
   assumes "f \<sim>[F] g"
   shows   "eventually (\<lambda>x. sgn (f x) = sgn (g x)) F"
 proof -
   from assms have "((\<lambda>x. sgn (if f x = 0 \<and> g x = 0 then 1 else f x / g x)) \<longlongrightarrow> sgn 1) F"
     unfolding asymp_equiv_def by (rule tendsto_sgn) simp_all
   from order_tendstoD(1)[OF this, of "1/2"]
     have "eventually (\<lambda>x. sgn (if f x = 0 \<and> g x = 0 then 1 else f x / g x) > 1/2) F"
     by simp
   thus "eventually (\<lambda>x. sgn (f x) = sgn (g x)) F"
   proof eventually_elim
     case (elim x)
     thus ?case
-      by (cases "f x" "0 :: real" rule: linorder_cases; 
+      by (cases "f x" "0 :: real" rule: linorder_cases;
           cases "g x" "0 :: real" rule: linorder_cases) simp_all
   qed
 qed
 
 lemma
   fixes f g :: "_ \<Rightarrow> real"
   assumes "f \<sim>[F] g"
   shows   asymp_equiv_eventually_same_sign: "eventually (\<lambda>x. sgn (f x) = sgn (g x)) F" (is ?th1)
     and   asymp_equiv_eventually_neg_iff:   "eventually (\<lambda>x. f x < 0 \<longleftrightarrow> g x < 0) F" (is ?th2)
     and   asymp_equiv_eventually_pos_iff:   "eventually (\<lambda>x. f x > 0 \<longleftrightarrow> g x > 0) F" (is ?th3)
 proof -
   from assms have "filterlim (\<lambda>x. if f x = 0 \<and> g x = 0 then 1 else f x / g x) (nhds 1) F"
     by (rule asymp_equivD)
   from order_tendstoD(1)[OF this zero_less_one]
     show ?th1 ?th2 ?th3
     by (eventually_elim; force simp: sgn_if field_split_simps split: if_splits)+
 qed
 
 lemma asymp_equiv_tendsto_transfer:
   assumes "f \<sim>[F] g" and "(f \<longlongrightarrow> c) F"
   shows   "(g \<longlongrightarrow> c) F"
 proof -
   let ?h = "\<lambda>x. (if g x = 0 \<and> f x = 0 then 1 else g x / f x) * f x"
   from assms(1) have "g \<sim>[F] f" by (rule asymp_equiv_symI)
   hence "filterlim (\<lambda>x. if g x = 0 \<and> f x = 0 then 1 else g x / f x) (nhds 1) F"
     by (rule asymp_equivD)
   from tendsto_mult[OF this assms(2)] have "(?h \<longlongrightarrow> c) F" by simp
-  moreover 
+  moreover
   have "eventually (\<lambda>x. ?h x = g x) F"
     using asymp_equiv_eventually_zeros[OF assms(1)] by eventually_elim simp
   ultimately show ?thesis
     by (rule Lim_transform_eventually)
 qed
 
 lemma tendsto_asymp_equiv_cong:
   assumes "f \<sim>[F] g"
   shows   "(f \<longlongrightarrow> c) F \<longleftrightarrow> (g \<longlongrightarrow> c) F"
 proof -
-  {
-    fix f g :: "'a \<Rightarrow> 'b"
-    assume *: "f \<sim>[F] g" "(g \<longlongrightarrow> c) F"
-    have "((\<lambda>x. g x * (if f x = 0 \<and> g x = 0 then 1 else f x / g x)) \<longlongrightarrow> c * 1) F"
-      by (intro tendsto_intros asymp_equivD *)
-    moreover 
+  have "(f \<longlongrightarrow> c * 1) F" if fg: "f \<sim>[F] g" and "(g \<longlongrightarrow> c) F" for f g :: "'a \<Rightarrow> 'b"
+  proof -
+    from that have *: "((\<lambda>x. g x * (if f x = 0 \<and> g x = 0 then 1 else f x / g x)) \<longlongrightarrow> c * 1) F"
+      by (intro tendsto_intros asymp_equivD)
     have "eventually (\<lambda>x. g x * (if f x = 0 \<and> g x = 0 then 1 else f x / g x) = f x) F"
-      using asymp_equiv_eventually_zeros[OF *(1)] by eventually_elim simp
-    ultimately have "(f \<longlongrightarrow> c * 1) F"
-      by (rule Lim_transform_eventually)
-  }
+      using asymp_equiv_eventually_zeros[OF fg] by eventually_elim simp
+    with * show ?thesis by (rule Lim_transform_eventually)
+  qed
   from this[of f g] this[of g f] assms show ?thesis by (auto simp: asymp_equiv_sym)
 qed
 
 
 lemma smallo_imp_eventually_sgn:
   fixes f g :: "real \<Rightarrow> real"
   assumes "g \<in> o(f)"
   shows   "eventually (\<lambda>x. sgn (f x + g x) = sgn (f x)) at_top"
 proof -
   have "0 < (1/2 :: real)" by simp
-  from landau_o.smallD[OF assms, OF this] 
+  from landau_o.smallD[OF assms, OF this]
     have "eventually (\<lambda>x. \<bar>g x\<bar> \<le> 1/2 * \<bar>f x\<bar>) at_top" by simp
   thus ?thesis
   proof eventually_elim
     case (elim x)
     thus ?case
-      by (cases "f x" "0::real" rule: linorder_cases; 
+      by (cases "f x" "0::real" rule: linorder_cases;
           cases "f x + g x" "0::real" rule: linorder_cases) simp_all
   qed
 qed
 
 context
 begin
 
 private lemma asymp_equiv_add_rightI:
   assumes "f \<sim>[F] g" "h \<in> o[F](g)"
   shows   "(\<lambda>x. f x + h x) \<sim>[F] g"
 proof -
   let ?T = "\<lambda>f g x. if f x = 0 \<and> g x = 0 then 1 else f x / g x"
   from landau_o.smallD[OF assms(2) zero_less_one]
     have ev: "eventually (\<lambda>x. g x = 0 \<longrightarrow> h x = 0) F" by eventually_elim auto
   have "(\<lambda>x. f x + h x) \<sim>[F] g \<longleftrightarrow> ((\<lambda>x. ?T f g x + h x / g x) \<longlongrightarrow> 1) F"
     unfolding asymp_equiv_def using ev
     by (intro tendsto_cong) (auto elim!: eventually_mono simp: field_split_simps)
   also have "\<dots> \<longleftrightarrow> ((\<lambda>x. ?T f g x + h x / g x) \<longlongrightarrow> 1 + 0) F" by simp
   also have \<dots> by (intro tendsto_intros asymp_equivD assms smalloD_tendsto)
   finally show "(\<lambda>x. f x + h x) \<sim>[F] g" .
 qed
 
 lemma asymp_equiv_add_right [asymp_equiv_simps]:
   assumes "h \<in> o[F](g)"
   shows   "(\<lambda>x. f x + h x) \<sim>[F] g \<longleftrightarrow> f \<sim>[F] g"
 proof
   assume "(\<lambda>x. f x + h x) \<sim>[F] g"
   from asymp_equiv_add_rightI[OF this, of "\<lambda>x. -h x"] assms show "f \<sim>[F] g"
     by simp
 qed (simp_all add: asymp_equiv_add_rightI assms)
 
 end
 
-lemma asymp_equiv_add_left [asymp_equiv_simps]: 
+lemma asymp_equiv_add_left [asymp_equiv_simps]:
   assumes "h \<in> o[F](g)"
   shows   "(\<lambda>x. h x + f x) \<sim>[F] g \<longleftrightarrow> f \<sim>[F] g"
   using asymp_equiv_add_right[OF assms] by (simp add: add.commute)
 
 lemma asymp_equiv_add_right' [asymp_equiv_simps]:
   assumes "h \<in> o[F](g)"
   shows   "g \<sim>[F] (\<lambda>x. f x + h x) \<longleftrightarrow> g \<sim>[F] f"
   using asymp_equiv_add_right[OF assms] by (simp add: asymp_equiv_sym)
-  
+
 lemma asymp_equiv_add_left' [asymp_equiv_simps]:
   assumes "h \<in> o[F](g)"
   shows   "g \<sim>[F] (\<lambda>x. h x + f x) \<longleftrightarrow> g \<sim>[F] f"
   using asymp_equiv_add_left[OF assms] by (simp add: asymp_equiv_sym)
 
 lemma smallo_imp_asymp_equiv:
   assumes "(\<lambda>x. f x - g x) \<in> o[F](g)"
   shows   "f \<sim>[F] g"
 proof -
   from assms have "(\<lambda>x. f x - g x + g x) \<sim>[F] g"
     by (subst asymp_equiv_add_left) simp_all
   thus ?thesis by simp
 qed
 
 lemma asymp_equiv_uminus [asymp_equiv_intros]:
   "f \<sim>[F] g \<Longrightarrow> (\<lambda>x. -f x) \<sim>[F] (\<lambda>x. -g x)"
   by (simp add: asymp_equiv_def cong: if_cong)
 
 lemma asymp_equiv_uminus_iff [asymp_equiv_simps]:
   "(\<lambda>x. -f x) \<sim>[F] g \<longleftrightarrow> f \<sim>[F] (\<lambda>x. -g x)"
   by (simp add: asymp_equiv_def cong: if_cong)
 
 lemma asymp_equiv_mult [asymp_equiv_intros]:
   fixes f1 f2 g1 g2 :: "'a \<Rightarrow> 'b :: real_normed_field"
   assumes "f1 \<sim>[F] g1" "f2 \<sim>[F] g2"
   shows   "(\<lambda>x. f1 x * f2 x) \<sim>[F] (\<lambda>x. g1 x * g2 x)"
 proof -
   let ?T = "\<lambda>f g x. if f x = 0 \<and> g x = 0 then 1 else f x / g x"
   let ?S = "\<lambda>x. (if f1 x = 0 \<and> g1 x = 0 then 1 - ?T f2 g2 x
                    else if f2 x = 0 \<and> g2 x = 0 then 1 - ?T f1 g1 x else 0)"
   let ?S' = "\<lambda>x. ?T (\<lambda>x. f1 x * f2 x) (\<lambda>x. g1 x * g2 x) x - ?T f1 g1 x * ?T f2 g2 x"
+  have A: "((\<lambda>x. 1 - ?T f g x) \<longlongrightarrow> 0) F" if "f \<sim>[F] g" for f g :: "'a \<Rightarrow> 'b"
+    by (rule tendsto_eq_intros refl asymp_equivD[OF that])+ simp_all
+
+  from assms have *: "((\<lambda>x. ?T f1 g1 x * ?T f2 g2 x) \<longlongrightarrow> 1 * 1) F"
+    by (intro tendsto_mult asymp_equivD)
   {
-    fix f g :: "'a \<Rightarrow> 'b" assume "f \<sim>[F] g"
-    have "((\<lambda>x. 1 - ?T f g x) \<longlongrightarrow> 0) F"
-      by (rule tendsto_eq_intros refl asymp_equivD[OF \<open>f \<sim>[F] g\<close>])+ simp_all
-  } note A = this    
-
-  from assms have "((\<lambda>x. ?T f1 g1 x * ?T f2 g2 x) \<longlongrightarrow> 1 * 1) F"
-    by (intro tendsto_mult asymp_equivD)
-  moreover {
     have "(?S \<longlongrightarrow> 0) F"
       by (intro filterlim_If assms[THEN A, THEN tendsto_mono[rotated]])
          (auto intro: le_infI1 le_infI2)
     moreover have "eventually (\<lambda>x. ?S x = ?S' x) F"
       using assms[THEN asymp_equiv_eventually_zeros] by eventually_elim auto
     ultimately have "(?S' \<longlongrightarrow> 0) F" by (rule Lim_transform_eventually)
   }
-  ultimately have "(?T (\<lambda>x. f1 x * f2 x) (\<lambda>x. g1 x * g2 x) \<longlongrightarrow> 1 * 1) F"
+  with * have "(?T (\<lambda>x. f1 x * f2 x) (\<lambda>x. g1 x * g2 x) \<longlongrightarrow> 1 * 1) F"
     by (rule Lim_transform)
-  thus ?thesis by (simp add: asymp_equiv_def)
+  then show ?thesis by (simp add: asymp_equiv_def)
 qed
 
 lemma asymp_equiv_power [asymp_equiv_intros]:
   "f \<sim>[F] g \<Longrightarrow> (\<lambda>x. f x ^ n) \<sim>[F] (\<lambda>x. g x ^ n)"
   by (induction n) (simp_all add: asymp_equiv_mult)
 
 lemma asymp_equiv_inverse [asymp_equiv_intros]:
   assumes "f \<sim>[F] g"
   shows   "(\<lambda>x. inverse (f x)) \<sim>[F] (\<lambda>x. inverse (g x))"
 proof -
   from tendsto_inverse[OF asymp_equivD[OF assms]]
     have "((\<lambda>x. if f x = 0 \<and> g x = 0 then 1 else g x / f x) \<longlongrightarrow> 1) F"
     by (simp add: if_distrib cong: if_cong)
   also have "(\<lambda>x. if f x = 0 \<and> g x = 0 then 1 else g x / f x) =
                (\<lambda>x. if f x = 0 \<and> g x = 0 then 1 else inverse (f x) / inverse (g x))"
     by (intro ext) (simp add: field_simps)
   finally show ?thesis by (simp add: asymp_equiv_def)
 qed
 
 lemma asymp_equiv_inverse_iff [asymp_equiv_simps]:
   "(\<lambda>x. inverse (f x)) \<sim>[F] (\<lambda>x. inverse (g x)) \<longleftrightarrow> f \<sim>[F] g"
 proof
   assume "(\<lambda>x. inverse (f x)) \<sim>[F] (\<lambda>x. inverse (g x))"
   hence "(\<lambda>x. inverse (inverse (f x))) \<sim>[F] (\<lambda>x. inverse (inverse (g x)))" (is ?P)
     by (rule asymp_equiv_inverse)
   also have "?P \<longleftrightarrow> f \<sim>[F] g" by (intro asymp_equiv_cong) simp_all
   finally show "f \<sim>[F] g" .
 qed (simp_all add: asymp_equiv_inverse)
 
 lemma asymp_equiv_divide [asymp_equiv_intros]:
   assumes "f1 \<sim>[F] g1" "f2 \<sim>[F] g2"
   shows   "(\<lambda>x. f1 x / f2 x) \<sim>[F] (\<lambda>x. g1 x / g2 x)"
   using asymp_equiv_mult[OF assms(1) asymp_equiv_inverse[OF assms(2)]] by (simp add: field_simps)
 
 lemma asymp_equiv_compose [asymp_equiv_intros]:
   assumes "f \<sim>[G] g" "filterlim h G F"
   shows   "f \<circ> h \<sim>[F] g \<circ> h"
 proof -
   let ?T = "\<lambda>f g x. if f x = 0 \<and> g x = 0 then 1 else f x / g x"
   have "f \<circ> h \<sim>[F] g \<circ> h \<longleftrightarrow> ((?T f g \<circ> h) \<longlongrightarrow> 1) F"
     by (simp add: asymp_equiv_def o_def)
   also have "\<dots> \<longleftrightarrow> (?T f g \<longlongrightarrow> 1) (filtermap h F)"
     by (rule tendsto_compose_filtermap)
   also have "\<dots>"
     by (rule tendsto_mono[of _ G]) (insert assms, simp_all add: asymp_equiv_def filterlim_def)
   finally show ?thesis .
 qed
 
 lemma asymp_equiv_compose':
   assumes "f \<sim>[G] g" "filterlim h G F"
   shows   "(\<lambda>x. f (h x)) \<sim>[F] (\<lambda>x. g (h x))"
   using asymp_equiv_compose[OF assms] by (simp add: o_def)
-  
+
 lemma asymp_equiv_powr_real [asymp_equiv_intros]:
   fixes f g :: "'a \<Rightarrow> real"
   assumes "f \<sim>[F] g" "eventually (\<lambda>x. f x \<ge> 0) F" "eventually (\<lambda>x. g x \<ge> 0) F"
   shows   "(\<lambda>x. f x powr y) \<sim>[F] (\<lambda>x. g x powr y)"
 proof -
   let ?T = "\<lambda>f g x. if f x = 0 \<and> g x = 0 then 1 else f x / g x"
   have "((\<lambda>x. ?T f g x powr y) \<longlongrightarrow> 1 powr y) F"
     by (intro tendsto_intros asymp_equivD[OF assms(1)]) simp_all
   hence "((\<lambda>x. ?T f g x powr y) \<longlongrightarrow> 1) F" by simp
   moreover have "eventually (\<lambda>x. ?T f g x powr y = ?T (\<lambda>x. f x powr y) (\<lambda>x. g x powr y) x) F"
     using asymp_equiv_eventually_zeros[OF assms(1)] assms(2,3)
     by eventually_elim (auto simp: powr_divide)
   ultimately show ?thesis unfolding asymp_equiv_def by (rule Lim_transform_eventually)
 qed
 
 lemma asymp_equiv_norm [asymp_equiv_intros]:
   fixes f g :: "'a \<Rightarrow> 'b :: real_normed_field"
   assumes "f \<sim>[F] g"
   shows   "(\<lambda>x. norm (f x)) \<sim>[F] (\<lambda>x. norm (g x))"
-  using tendsto_norm[OF asymp_equivD[OF assms]] 
+  using tendsto_norm[OF asymp_equivD[OF assms]]
   by (simp add: if_distrib asymp_equiv_def norm_divide cong: if_cong)
 
 lemma asymp_equiv_abs_real [asymp_equiv_intros]:
   fixes f g :: "'a \<Rightarrow> real"
   assumes "f \<sim>[F] g"
   shows   "(\<lambda>x. \<bar>f x\<bar>) \<sim>[F] (\<lambda>x. \<bar>g x\<bar>)"
-  using tendsto_rabs[OF asymp_equivD[OF assms]] 
+  using tendsto_rabs[OF asymp_equivD[OF assms]]
   by (simp add: if_distrib asymp_equiv_def cong: if_cong)
 
 lemma asymp_equiv_imp_eventually_le:
   assumes "f \<sim>[F] g" "c > 1"
   shows   "eventually (\<lambda>x. norm (f x) \<le> c * norm (g x)) F"
 proof -
   from order_tendstoD(2)[OF asymp_equivD[OF asymp_equiv_norm[OF assms(1)]] assms(2)]
        asymp_equiv_eventually_zeros[OF assms(1)]
     show ?thesis by eventually_elim (auto split: if_splits simp: field_simps)
 qed
 
 lemma asymp_equiv_imp_eventually_ge:
   assumes "f \<sim>[F] g" "c < 1"
   shows   "eventually (\<lambda>x. norm (f x) \<ge> c * norm (g x)) F"
 proof -
   from order_tendstoD(1)[OF asymp_equivD[OF asymp_equiv_norm[OF assms(1)]] assms(2)]
        asymp_equiv_eventually_zeros[OF assms(1)]
     show ?thesis by eventually_elim (auto split: if_splits simp: field_simps)
 qed
 
 lemma asymp_equiv_imp_bigo:
   assumes "f \<sim>[F] g"
   shows   "f \<in> O[F](g)"
 proof (rule bigoI)
   have "(3/2::real) > 1" by simp
   from asymp_equiv_imp_eventually_le[OF assms this]
     show "eventually (\<lambda>x. norm (f x) \<le> 3/2 * norm (g x)) F"
     by eventually_elim simp
 qed
 
 lemma asymp_equiv_imp_bigomega:
   "f \<sim>[F] g \<Longrightarrow> f \<in> \<Omega>[F](g)"
   using asymp_equiv_imp_bigo[of g F f] by (simp add: asymp_equiv_sym bigomega_iff_bigo)
 
 lemma asymp_equiv_imp_bigtheta:
   "f \<sim>[F] g \<Longrightarrow> f \<in> \<Theta>[F](g)"
   by (intro bigthetaI asymp_equiv_imp_bigo asymp_equiv_imp_bigomega)
 
 lemma asymp_equiv_at_infinity_transfer:
   assumes "f \<sim>[F] g" "filterlim f at_infinity F"
   shows   "filterlim g at_infinity F"
 proof -
   from assms(1) have "g \<in> \<Theta>[F](f)" by (rule asymp_equiv_imp_bigtheta[OF asymp_equiv_symI])
   also from assms have "f \<in> \<omega>[F](\<lambda>_. 1)" by (simp add: smallomega_1_conv_filterlim)
   finally show ?thesis by (simp add: smallomega_1_conv_filterlim)
 qed
 
 lemma asymp_equiv_at_top_transfer:
   fixes f g :: "_ \<Rightarrow> real"
   assumes "f \<sim>[F] g" "filterlim f at_top F"
   shows   "filterlim g at_top F"
 proof (rule filterlim_at_infinity_imp_filterlim_at_top)
   show "filterlim g at_infinity F"
     by (rule asymp_equiv_at_infinity_transfer[OF assms(1) filterlim_mono[OF assms(2)]])
        (auto simp: at_top_le_at_infinity)
   from assms(2) have "eventually (\<lambda>x. f x > 0) F"
     using filterlim_at_top_dense by blast
   with asymp_equiv_eventually_pos_iff[OF assms(1)] show "eventually (\<lambda>x. g x > 0) F"
     by eventually_elim blast
 qed
 
 lemma asymp_equiv_at_bot_transfer:
   fixes f g :: "_ \<Rightarrow> real"
   assumes "f \<sim>[F] g" "filterlim f at_bot F"
   shows   "filterlim g at_bot F"
   unfolding filterlim_uminus_at_bot
   by (rule asymp_equiv_at_top_transfer[of "\<lambda>x. -f x" F "\<lambda>x. -g x"])
-     (insert assms, auto simp: filterlim_uminus_at_bot asymp_equiv_uminus)  
+     (insert assms, auto simp: filterlim_uminus_at_bot asymp_equiv_uminus)
 
 lemma asymp_equivI'_const:
   assumes "((\<lambda>x. f x / g x) \<longlongrightarrow> c) F" "c \<noteq> 0"
   shows   "f \<sim>[F] (\<lambda>x. c * g x)"
   using tendsto_mult[OF assms(1) tendsto_const[of "inverse c"]] assms(2)
   by (intro asymp_equivI') (simp add: field_simps)
 
 lemma asymp_equivI'_inverse_const:
   assumes "((\<lambda>x. f x / g x) \<longlongrightarrow> inverse c) F" "c \<noteq> 0"
   shows   "(\<lambda>x. c * f x) \<sim>[F] g"
   using tendsto_mult[OF assms(1) tendsto_const[of "c"]] assms(2)
   by (intro asymp_equivI') (simp add: field_simps)
 
 lemma filterlim_at_bot_imp_at_infinity: "filterlim f at_bot F \<Longrightarrow> filterlim f at_infinity F"
   for f :: "_ \<Rightarrow> real" using at_bot_le_at_infinity filterlim_mono by blast
 
 lemma asymp_equiv_imp_diff_smallo:
   assumes "f \<sim>[F] g"
   shows   "(\<lambda>x. f x - g x) \<in> o[F](g)"
 proof (rule landau_o.smallI)
   fix c :: real assume "c > 0"
   hence c: "min c 1 > 0" by simp
   let ?h = "\<lambda>x. if f x = 0 \<and> g x = 0 then 1 else f x / g x"
   from assms have "((\<lambda>x. ?h x - 1) \<longlongrightarrow> 1 - 1) F"
     by (intro tendsto_diff asymp_equivD tendsto_const)
   from tendstoD[OF this c] show "eventually (\<lambda>x. norm (f x - g x) \<le> c * norm (g x)) F"
   proof eventually_elim
     case (elim x)
     from elim have "norm (f x - g x) \<le> norm (f x / g x - 1) * norm (g x)"
       by (subst norm_mult [symmetric]) (auto split: if_splits simp add: algebra_simps)
     also have "norm (f x / g x - 1) * norm (g x) \<le> c * norm (g x)" using elim
       by (auto split: if_splits simp: mult_right_mono)
     finally show ?case .
   qed
 qed
 
 lemma asymp_equiv_altdef:
   "f \<sim>[F] g \<longleftrightarrow> (\<lambda>x. f x - g x) \<in> o[F](g)"
   by (rule iffI[OF asymp_equiv_imp_diff_smallo smallo_imp_asymp_equiv])
 
 lemma asymp_equiv_0_left_iff [simp]: "(\<lambda>_. 0) \<sim>[F] f \<longleftrightarrow> eventually (\<lambda>x. f x = 0) F"
   and asymp_equiv_0_right_iff [simp]: "f \<sim>[F] (\<lambda>_. 0) \<longleftrightarrow> eventually (\<lambda>x. f x = 0) F"
   by (simp_all add: asymp_equiv_altdef landau_o.small_refl_iff)
 
 lemma asymp_equiv_sandwich_real:
   fixes f g l u :: "'a \<Rightarrow> real"
   assumes "l \<sim>[F] g" "u \<sim>[F] g" "eventually (\<lambda>x. f x \<in> {l x..u x}) F"
   shows   "f \<sim>[F] g"
   unfolding asymp_equiv_altdef
 proof (rule landau_o.smallI)
   fix c :: real assume c: "c > 0"
   have "eventually (\<lambda>x. norm (f x - g x) \<le> max (norm (l x - g x)) (norm (u x - g x))) F"
     using assms(3) by eventually_elim auto
   moreover have "eventually (\<lambda>x. norm (l x - g x) \<le> c * norm (g x)) F"
                 "eventually (\<lambda>x. norm (u x - g x) \<le> c * norm (g x)) F"
     using assms(1,2) by (auto simp: asymp_equiv_altdef dest: landau_o.smallD[OF _ c])
   hence "eventually (\<lambda>x. max (norm (l x - g x)) (norm (u x - g x)) \<le> c * norm (g x)) F"
     by eventually_elim simp
   ultimately show "eventually (\<lambda>x. norm (f x - g x) \<le> c * norm (g x)) F"
     by eventually_elim (rule order.trans)
 qed
 
 lemma asymp_equiv_sandwich_real':
   fixes f g l u :: "'a \<Rightarrow> real"
   assumes "f \<sim>[F] l" "f \<sim>[F] u" "eventually (\<lambda>x. g x \<in> {l x..u x}) F"
   shows   "f \<sim>[F] g"
   using asymp_equiv_sandwich_real[of l F f u g] assms by (simp add: asymp_equiv_sym)
 
 lemma asymp_equiv_sandwich_real'':
   fixes f g l u :: "'a \<Rightarrow> real"
   assumes "l1 \<sim>[F] u1" "u1 \<sim>[F] l2" "l2 \<sim>[F] u2"
           "eventually (\<lambda>x. f x \<in> {l1 x..u1 x}) F" "eventually (\<lambda>x. g x \<in> {l2 x..u2 x}) F"
   shows   "f \<sim>[F] g"
   by (rule asymp_equiv_sandwich_real[OF asymp_equiv_sandwich_real'[OF _ _ assms(5)]
              asymp_equiv_sandwich_real'[OF _ _ assms(5)] assms(4)];
       blast intro: asymp_equiv_trans assms(1,2,3))+
 
 end
diff --git a/src/HOL/Tools/Argo/argo_real.ML b/src/HOL/Tools/Argo/argo_real.ML
--- a/src/HOL/Tools/Argo/argo_real.ML
+++ b/src/HOL/Tools/Argo/argo_real.ML
@@ -1,333 +1,332 @@
 (*  Title:      HOL/Tools/Argo/argo_real.ML
     Author:     Sascha Boehme
 
 Extension of the Argo tactic for the reals.
 *)
 
 structure Argo_Real: sig end =
 struct
 
 (* translating input terms *)
 
-fun trans_type _ \<^typ>\<open>Real.real\<close> tcx = SOME (Argo_Expr.Real, tcx)
+fun trans_type _ \<^Type>\<open>real\<close> tcx = SOME (Argo_Expr.Real, tcx)
   | trans_type _ _ _ = NONE
 
-fun trans_term f (@{const Groups.uminus_class.uminus (real)} $ t) tcx =
+fun trans_term f \<^Const_>\<open>uminus \<open>\<^Type>\<open>real\<close>\<close> for t\<close> tcx =
       tcx |> f t |>> Argo_Expr.mk_neg |> SOME
-  | trans_term f (@{const Groups.plus_class.plus (real)} $ t1 $ t2) tcx =
+  | trans_term f \<^Const_>\<open>plus \<open>\<^Type>\<open>real\<close>\<close> for t1 t2\<close> tcx =
       tcx |> f t1 ||>> f t2 |>> uncurry Argo_Expr.mk_add2 |> SOME
-  | trans_term f (@{const Groups.minus_class.minus (real)} $ t1 $ t2) tcx =
+  | trans_term f \<^Const_>\<open>minus \<open>\<^Type>\<open>real\<close>\<close> for t1 t2\<close> tcx =
       tcx |> f t1 ||>> f t2 |>> uncurry Argo_Expr.mk_sub |> SOME
-  | trans_term f (@{const Groups.times_class.times (real)} $ t1 $ t2) tcx =
+  | trans_term f \<^Const_>\<open>times \<open>\<^Type>\<open>real\<close>\<close> for t1 t2\<close> tcx =
       tcx |> f t1 ||>> f t2 |>> uncurry Argo_Expr.mk_mul |> SOME
-  | trans_term f (@{const Rings.divide_class.divide (real)} $ t1 $ t2) tcx =
+  | trans_term f \<^Const_>\<open>divide \<open>\<^Type>\<open>real\<close>\<close> for t1 t2\<close> tcx =
       tcx |> f t1 ||>> f t2 |>> uncurry Argo_Expr.mk_div |> SOME
-  | trans_term f (@{const Orderings.ord_class.min (real)} $ t1 $ t2) tcx =
+  | trans_term f \<^Const_>\<open>min \<open>\<^Type>\<open>real\<close>\<close> for t1 t2\<close> tcx =
       tcx |> f t1 ||>> f t2 |>> uncurry Argo_Expr.mk_min |> SOME
-  | trans_term f (@{const Orderings.ord_class.max (real)} $ t1 $ t2) tcx =
+  | trans_term f \<^Const_>\<open>max \<open>\<^Type>\<open>real\<close>\<close> for t1 t2\<close> tcx =
       tcx |> f t1 ||>> f t2 |>> uncurry Argo_Expr.mk_max |> SOME
-  | trans_term f (@{const Groups.abs_class.abs (real)} $ t) tcx =
+  | trans_term f \<^Const_>\<open>abs \<open>\<^Type>\<open>real\<close>\<close> for t\<close> tcx =
       tcx |> f t |>> Argo_Expr.mk_abs |> SOME
-  | trans_term f (@{const Orderings.ord_class.less (real)} $ t1 $ t2) tcx =
+  | trans_term f \<^Const_>\<open>less \<open>\<^Type>\<open>real\<close>\<close> for t1 t2\<close> tcx =
       tcx |> f t1 ||>> f t2 |>> uncurry Argo_Expr.mk_lt |> SOME
-  | trans_term f (@{const Orderings.ord_class.less_eq (real)} $ t1 $ t2) tcx =
+  | trans_term f \<^Const_>\<open>less_eq \<open>\<^Type>\<open>real\<close>\<close> for t1 t2\<close> tcx =
       tcx |> f t1 ||>> f t2 |>> uncurry Argo_Expr.mk_le |> SOME
   | trans_term _ t tcx =
       (case try HOLogic.dest_number t of
-        SOME (\<^typ>\<open>Real.real\<close>, n) => SOME (Argo_Expr.mk_num (Rat.of_int n), tcx)
+        SOME (\<^Type>\<open>real\<close>, n) => SOME (Argo_Expr.mk_num (Rat.of_int n), tcx)
       | _ => NONE)
 
 
 (* reverse translation *)
 
-fun mk_plus t1 t2 = @{const Groups.plus_class.plus (real)} $ t1 $ t2
+fun mk_plus t1 t2 = \<^Const>\<open>plus \<open>\<^Type>\<open>real\<close>\<close> for t1 t2\<close>
 fun mk_sum ts = uncurry (fold_rev mk_plus) (split_last ts)
-fun mk_times t1 t2 = @{const Groups.times_class.times (real)} $ t1 $ t2
-fun mk_divide t1 t2 = @{const Rings.divide_class.divide (real)} $ t1 $ t2
-fun mk_le t1 t2 = @{const Orderings.ord_class.less_eq (real)} $ t1 $ t2
-fun mk_lt t1 t2 = @{const Orderings.ord_class.less (real)} $ t1 $ t2
+fun mk_times t1 t2 = \<^Const>\<open>times \<open>\<^Type>\<open>real\<close>\<close> for t1 t2\<close>
+fun mk_divide t1 t2 = \<^Const>\<open>divide \<open>\<^Type>\<open>real\<close>\<close> for t1 t2\<close>
+fun mk_le t1 t2 = \<^Const>\<open>less_eq \<open>\<^Type>\<open>real\<close>\<close> for t1 t2\<close>
+fun mk_lt t1 t2 = \<^Const>\<open>less \<open>\<^Type>\<open>real\<close>\<close> for t1 t2\<close>
 
-fun mk_real_num i = HOLogic.mk_number \<^typ>\<open>Real.real\<close> i
+fun mk_real_num i = HOLogic.mk_number \<^Type>\<open>real\<close> i
 
 fun mk_number n =
   let val (p, q) = Rat.dest n
   in if q = 1 then mk_real_num p else mk_divide (mk_real_num p) (mk_real_num q) end
 
 fun term_of _ (Argo_Expr.E (Argo_Expr.Num n, _)) = SOME (mk_number n)
-  | term_of f (Argo_Expr.E (Argo_Expr.Neg, [e])) =
-      SOME (@{const Groups.uminus_class.uminus (real)} $ f e)
+  | term_of f (Argo_Expr.E (Argo_Expr.Neg, [e])) = SOME \<^Const>\<open>uminus \<open>\<^Type>\<open>real\<close>\<close> for \<open>f e\<close>\<close>
   | term_of f (Argo_Expr.E (Argo_Expr.Add, es)) = SOME (mk_sum (map f es))
   | term_of f (Argo_Expr.E (Argo_Expr.Sub, [e1, e2])) =
-      SOME (@{const Groups.minus_class.minus (real)} $ f e1 $ f e2)
+      SOME \<^Const>\<open>minus \<open>\<^Type>\<open>real\<close>\<close> for \<open>f e1\<close> \<open>f e2\<close>\<close>
   | term_of f (Argo_Expr.E (Argo_Expr.Mul, [e1, e2])) = SOME (mk_times (f e1) (f e2))
   | term_of f (Argo_Expr.E (Argo_Expr.Div, [e1, e2])) = SOME (mk_divide (f e1) (f e2))
   | term_of f (Argo_Expr.E (Argo_Expr.Min, [e1, e2])) =
-      SOME (@{const Orderings.ord_class.min (real)} $ f e1 $ f e2)
+      SOME \<^Const>\<open>min \<open>\<^Type>\<open>real\<close>\<close> for \<open>f e1\<close> \<open>f e2\<close>\<close>
   | term_of f (Argo_Expr.E (Argo_Expr.Max, [e1, e2])) =
-      SOME (@{const Orderings.ord_class.max (real)} $ f e1 $ f e2)
-  | term_of f (Argo_Expr.E (Argo_Expr.Abs, [e])) = SOME (@{const Groups.abs_class.abs (real)} $ f e)
+      SOME \<^Const>\<open>max \<open>\<^Type>\<open>real\<close>\<close> for \<open>f e1\<close> \<open>f e2\<close>\<close>
+  | term_of f (Argo_Expr.E (Argo_Expr.Abs, [e])) = SOME \<^Const>\<open>abs \<open>\<^Type>\<open>real\<close>\<close> for \<open>f e\<close>\<close>
   | term_of f (Argo_Expr.E (Argo_Expr.Le, [e1, e2])) = SOME (mk_le (f e1) (f e2))
   | term_of f (Argo_Expr.E (Argo_Expr.Lt, [e1, e2])) = SOME (mk_lt (f e1) (f e2))
   | term_of _ _ = NONE
 
 
 (* proof replay for rewrite steps *)
 
 fun mk_rewr thm = thm RS @{thm eq_reflection}
 
 fun by_simp ctxt t = 
   let fun prove {context, ...} = HEADGOAL (Simplifier.simp_tac context)
   in Goal.prove ctxt [] [] (HOLogic.mk_Trueprop t) prove end
 
 fun prove_num_pred ctxt n =
   by_simp ctxt (uncurry mk_lt (apply2 mk_number (if @0 < n then (@0, n) else (n, @0))))
 
 fun simp_conv ctxt t = Conv.rewr_conv (mk_rewr (by_simp ctxt t))
 
 fun nums_conv mk f ctxt n m =
   simp_conv ctxt (HOLogic.mk_eq (mk (mk_number n) (mk_number m), mk_number (f (n, m))))
 
 val add_nums_conv = nums_conv mk_plus (op +)
 val mul_nums_conv = nums_conv mk_times (op *)
 val div_nums_conv = nums_conv mk_divide (op /)
 fun inv_num_conv ctxt = nums_conv mk_divide (fn (_, n) => Rat.inv n) ctxt @1
 
 fun cmp_nums_conv ctxt b ct =
-  let val t = if b then \<^const>\<open>HOL.True\<close> else \<^const>\<open>HOL.False\<close>
+  let val t = if b then \<^Const>\<open>True\<close> else \<^Const>\<open>False\<close>
   in simp_conv ctxt (HOLogic.mk_eq (Thm.term_of ct, t)) ct end
 
 local
 
-fun is_add2 (@{const Groups.plus_class.plus (real)} $ _ $ _) = true
+fun is_add2 \<^Const_>\<open>plus \<open>\<^Type>\<open>real\<close>\<close> for _ _\<close> = true
   | is_add2 _ = false
 
-fun is_add3 (@{const Groups.plus_class.plus (real)} $ _ $ t) = is_add2 t
+fun is_add3 \<^Const_>\<open>plus \<open>\<^Type>\<open>real\<close>\<close> for _ t\<close> = is_add2 t
   | is_add3 _ = false
 
 val flatten_thm = mk_rewr @{lemma "(a::real) + b + c = a + (b + c)" by simp}
   
 fun flatten_conv ct =
   if is_add2 (Thm.term_of ct) then Argo_Tactic.flatten_conv flatten_conv flatten_thm ct
   else Conv.all_conv ct
 
 val swap_conv = Conv.rewrs_conv (map mk_rewr @{lemma 
   "(a::real) + (b + c) = b + (a + c)"
   "(a::real) + b = b + a"
   by simp_all})
 
 val assoc_conv = Conv.rewr_conv (mk_rewr @{lemma "(a::real) + (b + c) = (a + b) + c" by simp})
 
 val norm_monom_thm = mk_rewr @{lemma "1 * (a::real) = a" by simp}
 fun norm_monom_conv n = if n = @1 then Conv.rewr_conv norm_monom_thm else Conv.all_conv
 
 val add2_thms = map mk_rewr @{lemma
   "n * (a::real) + m * a = (n + m) * a"
   "n * (a::real) + a = (n + 1) * a"
   "(a::real) + m * a = (1 + m) * a"
   "(a::real) + a = (1 + 1) * a"
   by algebra+}
 
 val add3_thms = map mk_rewr @{lemma
   "n * (a::real) + (m * a + b) = (n + m) * a + b"
   "n * (a::real) + (a + b) = (n + 1) * a + b"
   "(a::real) + (m * a + b) = (1 + m) * a + b"
   "(a::real) + (a + b) = (1 + 1) * a + b"
   by algebra+}
 
 fun choose_conv cv2 cv3 ct = if is_add3 (Thm.term_of ct) then cv3 ct else cv2 ct
 
 fun join_num_conv ctxt n m =
   let val conv = add_nums_conv ctxt n m
   in choose_conv conv (assoc_conv then_conv Conv.arg1_conv conv) end
 
 fun join_monom_conv ctxt n m =
   let
     val conv = Conv.arg1_conv (add_nums_conv ctxt n m) then_conv norm_monom_conv (n + m)
     fun seq_conv thms cv = Conv.rewrs_conv thms then_conv cv
   in choose_conv (seq_conv add2_thms conv) (seq_conv add3_thms (Conv.arg1_conv conv)) end
 
 fun join_conv NONE = join_num_conv
   | join_conv (SOME _) = join_monom_conv
 
 fun bubble_down_conv _ _ [] ct = Conv.no_conv ct
   | bubble_down_conv _ _ [_] ct = Conv.all_conv ct
   | bubble_down_conv ctxt i ((m1 as (n1, i1)) :: (m2 as (n2, i2)) :: ms) ct =
       if i1 = i then
         if i2 = i then
           (join_conv i ctxt n1 n2 then_conv bubble_down_conv ctxt i ((n1 + n2, i) :: ms)) ct
         else (swap_conv then_conv Conv.arg_conv (bubble_down_conv ctxt i (m1 :: ms))) ct
       else Conv.arg_conv (bubble_down_conv ctxt i (m2 :: ms)) ct
 
 fun drop_var i ms = filter_out (fn (_, i') => i' = i) ms
 
 fun permute_conv _ [] [] ct = Conv.all_conv ct
   | permute_conv ctxt (ms as ((_, i) :: _)) [] ct =
       (bubble_down_conv ctxt i ms then_conv permute_conv ctxt (drop_var i ms) []) ct
   | permute_conv ctxt ms1 ms2 ct =
       let val (ms2', (_, i)) = split_last ms2
       in (bubble_down_conv ctxt i ms1 then_conv permute_conv ctxt (drop_var i ms1) ms2') ct end
 
 val no_monom_conv = Conv.rewr_conv (mk_rewr @{lemma "0 * (a::real) = 0" by simp})
 
 val norm_sum_conv = Conv.rewrs_conv (map mk_rewr @{lemma
   "0 * (a::real) + b = b"
   "(a::real) + 0 * b = a"
   "0 + (a::real) = a"
   "(a::real) + 0 = a"
   by simp_all})
 
 fun drop0_conv ct =
   if is_add2 (Thm.term_of ct) then
     ((norm_sum_conv then_conv drop0_conv) else_conv Conv.arg_conv drop0_conv) ct
   else Conv.try_conv no_monom_conv ct
 
 fun full_add_conv ctxt ms1 ms2 =
   if eq_list (op =) (ms1, ms2) then flatten_conv
   else flatten_conv then_conv permute_conv ctxt ms1 ms2 then_conv drop0_conv
 
 in
 
 fun add_conv ctxt (ms1, ms2 as [(n, NONE)]) =
       if n = @0 then full_add_conv ctxt ms1 [] else full_add_conv ctxt ms1 ms2
   | add_conv ctxt (ms1, ms2) = full_add_conv ctxt ms1 ms2
 
 end
 
 val mul_suml_thm = mk_rewr @{lemma "((x::real) + y) * z = x * z + y * z" by (rule ring_distribs)}
 val mul_sumr_thm = mk_rewr @{lemma "(x::real) * (y + z) = x * y + x * z" by (rule ring_distribs)}
 fun mul_sum_conv thm ct =
   Conv.try_conv (Conv.rewr_conv thm then_conv Conv.binop_conv (mul_sum_conv thm)) ct
 
 val div_sum_thm = mk_rewr @{lemma "((x::real) + y) / z = x / z + y / z"
   by (rule add_divide_distrib)}
 fun div_sum_conv ct =
   Conv.try_conv (Conv.rewr_conv div_sum_thm then_conv Conv.binop_conv div_sum_conv) ct
 
 fun var_of_add_cmp (_ $ _ $ (_ $ _ $ (_ $ _ $ Var v))) = v
   | var_of_add_cmp t = raise TERM ("var_of_add_cmp", [t])
 
 fun add_cmp_conv ctxt n thm =
   let val v = var_of_add_cmp (Thm.prop_of thm) in
     Conv.rewr_conv
       (Thm.instantiate (TVars.empty, Vars.make [(v, Thm.cterm_of ctxt (mk_number n))]) thm)
   end
 
 fun mul_cmp_conv ctxt n pos_thm neg_thm =
   let val thm = if @0 < n then pos_thm else neg_thm
   in Conv.rewr_conv (prove_num_pred ctxt n RS thm) end
 
 val neg_thm = mk_rewr @{lemma "-(x::real) = -1 * x" by simp}
 val sub_thm = mk_rewr @{lemma "(x::real) - y = x + -1 * y" by simp}
 val mul_zero_thm = mk_rewr @{lemma "0 * (x::real) = 0" by (rule mult_zero_left)}
 val mul_one_thm = mk_rewr @{lemma "1 * (x::real) = x" by (rule mult_1)}
 val mul_comm_thm = mk_rewr @{lemma "(x::real) * y = y * x" by simp}
 val mul_assocl_thm = mk_rewr @{lemma "((x::real) * y) * z = x * (y * z)" by simp}
 val mul_assocr_thm = mk_rewr @{lemma "(x::real) * (y * z) = (x * y) * z" by simp}
 val mul_divl_thm = mk_rewr @{lemma "((x::real) / y) * z = (x * z) / y" by simp}
 val mul_divr_thm = mk_rewr @{lemma "(x::real) * (y / z) = (x * y) / z" by simp}
 val div_zero_thm = mk_rewr @{lemma "0 / (x::real) = 0" by (rule div_0)}
 val div_one_thm = mk_rewr @{lemma "(x::real) / 1 = x" by (rule div_by_1)}
 val div_numl_thm = mk_rewr @{lemma "(x::real) / y = x * (1 / y)" by simp}
 val div_numr_thm = mk_rewr @{lemma "(x::real) / y = (1 / y) * x" by simp}
 val div_mull_thm = mk_rewr @{lemma "((x::real) * y) / z = x * (y / z)" by simp}
 val div_mulr_thm = mk_rewr @{lemma "(x::real) / (y * z) = (1 / y) * (x / z)" by simp}
 val div_divl_thm = mk_rewr @{lemma "((x::real) / y) / z = x / (y * z)" by simp}
 val div_divr_thm = mk_rewr @{lemma "(x::real) / (y / z) = (x * z) / y" by simp}
 val min_eq_thm = mk_rewr @{lemma "min (x::real) x = x" by (simp add: min_def)}
 val min_lt_thm = mk_rewr @{lemma "min (x::real) y = (if x <= y then x else y)" by (rule min_def)}
 val min_gt_thm = mk_rewr @{lemma "min (x::real) y = (if y <= x then y else x)"
   by (simp add: min_def)}
 val max_eq_thm = mk_rewr @{lemma "max (x::real) x = x" by (simp add: max_def)}
 val max_lt_thm = mk_rewr @{lemma "max (x::real) y = (if x <= y then y else x)" by (rule max_def)}
 val max_gt_thm = mk_rewr @{lemma "max (x::real) y = (if y <= x then x else y)"
   by (simp add: max_def)}
 val abs_thm = mk_rewr @{lemma "abs (x::real) = (if 0 <= x then x else -x)" by simp}
 val sub_eq_thm = mk_rewr @{lemma "((x::real) = y) = (x - y = 0)" by simp}
 val eq_le_thm = mk_rewr @{lemma "((x::real) = y) = ((x \<le> y) \<and> (y \<le> x))" by (rule order_eq_iff)}
 val add_le_thm = mk_rewr @{lemma "((x::real) \<le> y) = (x + n \<le> y + n)" by simp}
 val add_lt_thm = mk_rewr @{lemma "((x::real) < y) = (x + n < y + n)" by simp}
 val sub_le_thm = mk_rewr @{lemma "((x::real) <= y) = (x - y <= 0)" by simp}
 val sub_lt_thm = mk_rewr @{lemma "((x::real) < y) = (x - y < 0)" by simp}
 val pos_mul_le_thm = mk_rewr @{lemma "0 < n ==> ((x::real) <= y) = (n * x <= n * y)" by simp}
 val neg_mul_le_thm = mk_rewr @{lemma "n < 0 ==> ((x::real) <= y) = (n * y <= n * x)" by simp}
 val pos_mul_lt_thm = mk_rewr @{lemma "0 < n ==> ((x::real) < y) = (n * x < n * y)" by simp}
 val neg_mul_lt_thm = mk_rewr @{lemma "n < 0 ==> ((x::real) < y) = (n * y < n * x)" by simp}
 val not_le_thm = mk_rewr @{lemma "(\<not>((x::real) \<le> y)) = (y < x)" by auto}
 val not_lt_thm = mk_rewr @{lemma "(\<not>((x::real) < y)) = (y \<le> x)" by auto}
 
 fun replay_rewr _ Argo_Proof.Rewr_Neg = Conv.rewr_conv neg_thm
   | replay_rewr ctxt (Argo_Proof.Rewr_Add ps) = add_conv ctxt ps
   | replay_rewr _ Argo_Proof.Rewr_Sub = Conv.rewr_conv sub_thm
   | replay_rewr _ Argo_Proof.Rewr_Mul_Zero = Conv.rewr_conv mul_zero_thm
   | replay_rewr _ Argo_Proof.Rewr_Mul_One = Conv.rewr_conv mul_one_thm
   | replay_rewr ctxt (Argo_Proof.Rewr_Mul_Nums (n, m)) = mul_nums_conv ctxt n m
   | replay_rewr _ Argo_Proof.Rewr_Mul_Comm = Conv.rewr_conv mul_comm_thm
   | replay_rewr _ (Argo_Proof.Rewr_Mul_Assoc Argo_Proof.Left) = Conv.rewr_conv mul_assocl_thm
   | replay_rewr _ (Argo_Proof.Rewr_Mul_Assoc Argo_Proof.Right) = Conv.rewr_conv mul_assocr_thm
   | replay_rewr _ (Argo_Proof.Rewr_Mul_Sum Argo_Proof.Left) = mul_sum_conv mul_suml_thm
   | replay_rewr _ (Argo_Proof.Rewr_Mul_Sum Argo_Proof.Right) = mul_sum_conv mul_sumr_thm
   | replay_rewr _ (Argo_Proof.Rewr_Mul_Div Argo_Proof.Left) = Conv.rewr_conv mul_divl_thm
   | replay_rewr _ (Argo_Proof.Rewr_Mul_Div Argo_Proof.Right) = Conv.rewr_conv mul_divr_thm
   | replay_rewr _ Argo_Proof.Rewr_Div_Zero = Conv.rewr_conv div_zero_thm
   | replay_rewr _ Argo_Proof.Rewr_Div_One = Conv.rewr_conv div_one_thm
   | replay_rewr ctxt (Argo_Proof.Rewr_Div_Nums (n, m)) = div_nums_conv ctxt n m
   | replay_rewr _ (Argo_Proof.Rewr_Div_Num (Argo_Proof.Left, _)) = Conv.rewr_conv div_numl_thm
   | replay_rewr ctxt (Argo_Proof.Rewr_Div_Num (Argo_Proof.Right, n)) =
       Conv.rewr_conv div_numr_thm then_conv Conv.arg1_conv (inv_num_conv ctxt n)
   | replay_rewr _ (Argo_Proof.Rewr_Div_Mul (Argo_Proof.Left, _)) = Conv.rewr_conv div_mull_thm
   | replay_rewr ctxt (Argo_Proof.Rewr_Div_Mul (Argo_Proof.Right, n)) =
       Conv.rewr_conv div_mulr_thm then_conv Conv.arg1_conv (inv_num_conv ctxt n)
   | replay_rewr _ (Argo_Proof.Rewr_Div_Div Argo_Proof.Left) = Conv.rewr_conv div_divl_thm
   | replay_rewr _ (Argo_Proof.Rewr_Div_Div Argo_Proof.Right) = Conv.rewr_conv div_divr_thm
   | replay_rewr _ Argo_Proof.Rewr_Div_Sum = div_sum_conv
   | replay_rewr _ Argo_Proof.Rewr_Min_Eq = Conv.rewr_conv min_eq_thm
   | replay_rewr _ Argo_Proof.Rewr_Min_Lt = Conv.rewr_conv min_lt_thm
   | replay_rewr _ Argo_Proof.Rewr_Min_Gt = Conv.rewr_conv min_gt_thm
   | replay_rewr _ Argo_Proof.Rewr_Max_Eq = Conv.rewr_conv max_eq_thm
   | replay_rewr _ Argo_Proof.Rewr_Max_Lt = Conv.rewr_conv max_lt_thm
   | replay_rewr _ Argo_Proof.Rewr_Max_Gt = Conv.rewr_conv max_gt_thm
   | replay_rewr _ Argo_Proof.Rewr_Abs = Conv.rewr_conv abs_thm
   | replay_rewr ctxt (Argo_Proof.Rewr_Eq_Nums b) = cmp_nums_conv ctxt b
   | replay_rewr _ Argo_Proof.Rewr_Eq_Sub = Conv.rewr_conv sub_eq_thm
   | replay_rewr _ Argo_Proof.Rewr_Eq_Le = Conv.rewr_conv eq_le_thm
   | replay_rewr ctxt (Argo_Proof.Rewr_Ineq_Nums (_, b)) = cmp_nums_conv ctxt b
   | replay_rewr ctxt (Argo_Proof.Rewr_Ineq_Add (Argo_Proof.Le, n)) =
       add_cmp_conv ctxt n add_le_thm
   | replay_rewr ctxt (Argo_Proof.Rewr_Ineq_Add (Argo_Proof.Lt, n)) =
       add_cmp_conv ctxt n add_lt_thm
   | replay_rewr _ (Argo_Proof.Rewr_Ineq_Sub Argo_Proof.Le) = Conv.rewr_conv sub_le_thm
   | replay_rewr _ (Argo_Proof.Rewr_Ineq_Sub Argo_Proof.Lt) = Conv.rewr_conv sub_lt_thm
   | replay_rewr ctxt (Argo_Proof.Rewr_Ineq_Mul (Argo_Proof.Le, n)) =
       mul_cmp_conv ctxt n pos_mul_le_thm neg_mul_le_thm
   | replay_rewr ctxt (Argo_Proof.Rewr_Ineq_Mul (Argo_Proof.Lt, n)) =
       mul_cmp_conv ctxt n pos_mul_lt_thm neg_mul_lt_thm
   | replay_rewr _ (Argo_Proof.Rewr_Not_Ineq Argo_Proof.Le) = Conv.rewr_conv not_le_thm
   | replay_rewr _ (Argo_Proof.Rewr_Not_Ineq Argo_Proof.Lt) = Conv.rewr_conv not_lt_thm
   | replay_rewr _ _ = Conv.no_conv
 
 
 (* proof replay *)
 
 val combine_thms = @{lemma
   "(a::real) < b ==> c < d ==> a + c < b + d"
   "(a::real) < b ==> c <= d ==> a + c < b + d"
   "(a::real) <= b ==> c < d ==> a + c < b + d"
   "(a::real) <= b ==> c <= d ==> a + c <= b + d"
   by auto}
 
 fun combine thm1 thm2 = hd (Argo_Tactic.discharges thm2 (Argo_Tactic.discharges thm1 combine_thms))
 
 fun replay _ _ Argo_Proof.Linear_Comb prems = SOME (uncurry (fold_rev combine) (split_last prems))
   | replay _ _ _ _ = NONE
 
 
 (* real extension of the Argo solver *)
 
 val _ = Theory.setup (Argo_Tactic.add_extension {
   trans_type = trans_type,
   trans_term = trans_term,
   term_of = term_of,
   replay_rewr = replay_rewr,
   replay = replay})
 
 end
diff --git a/src/HOL/Tools/Argo/argo_tactic.ML b/src/HOL/Tools/Argo/argo_tactic.ML
--- a/src/HOL/Tools/Argo/argo_tactic.ML
+++ b/src/HOL/Tools/Argo/argo_tactic.ML
@@ -1,733 +1,731 @@
 (*  Title:      HOL/Tools/Argo/argo_tactic.ML
     Author:     Sascha Boehme
 
 HOL method and tactic for the Argo solver.
 *)
 
 signature ARGO_TACTIC =
 sig
   val trace: string Config.T
   val timeout: real Config.T
 
   (* extending the tactic *)
   type trans_context =
     Name.context * Argo_Expr.typ Typtab.table * (string * Argo_Expr.typ) Termtab.table
   type ('a, 'b) trans = 'a -> trans_context -> 'b * trans_context
   type ('a, 'b) trans' = 'a -> trans_context -> ('b * trans_context) option
   type extension = {
     trans_type: (typ, Argo_Expr.typ) trans -> (typ, Argo_Expr.typ) trans',
     trans_term: (term, Argo_Expr.expr) trans -> (term, Argo_Expr.expr) trans',
     term_of: (Argo_Expr.expr -> term) -> Argo_Expr.expr -> term option,
     replay_rewr: Proof.context -> Argo_Proof.rewrite -> conv,
     replay: (Argo_Expr.expr -> cterm) -> Proof.context -> Argo_Proof.rule -> thm list -> thm option}
   val add_extension: extension -> theory -> theory
 
   (* proof utilities *)
   val discharges: thm -> thm list -> thm list
   val flatten_conv: conv -> thm -> conv
 
   (* interface to the tactic as well as the underlying checker and prover *)
   datatype result = Satisfiable of term -> bool option | Unsatisfiable
   val check: term list -> Proof.context -> result * Proof.context
   val prove: thm list -> Proof.context -> thm option * Proof.context
   val argo_tac: Proof.context -> thm list -> int -> tactic
 end
 
 structure Argo_Tactic: ARGO_TACTIC =
 struct
 
 (* readable fresh names for terms *)
 
 fun fresh_name n = Name.variant (case Long_Name.base_name n of "" => "x" | n' => n')
 
 fun fresh_type_name (Type (n, _)) = fresh_name n
   | fresh_type_name (TFree (n, _)) = fresh_name n
   | fresh_type_name (TVar ((n, i), _)) = fresh_name (n ^ "." ^ string_of_int i)
 
 fun fresh_term_name (Const (n, _)) = fresh_name n
   | fresh_term_name (Free (n, _)) = fresh_name n
   | fresh_term_name (Var ((n, i), _)) = fresh_name (n ^ "." ^ string_of_int i)
   | fresh_term_name _ = fresh_name ""
 
 
 (* tracing *)
 
 datatype mode = None | Basic | Full
 
 fun string_of_mode None = "none"
   | string_of_mode Basic = "basic"
   | string_of_mode Full = "full"
 
 fun requires_mode None = []
   | requires_mode Basic = [Basic, Full]
   | requires_mode Full = [Full]
 
 val trace = Attrib.setup_config_string \<^binding>\<open>argo_trace\<close> (K (string_of_mode None))
 
 fun allows_mode ctxt = exists (equal (Config.get ctxt trace) o string_of_mode) o requires_mode
 
 fun output mode ctxt msg = if allows_mode ctxt mode then Output.tracing ("Argo: " ^ msg) else ()
 val tracing = output Basic
 val full_tracing = output Full
 
 fun with_mode mode ctxt f = if allows_mode ctxt mode then f ctxt else ()
 val with_tracing = with_mode Basic
 val with_full_tracing = with_mode Full
 
 
 (* timeout *)
 
 val timeout = Attrib.setup_config_real \<^binding>\<open>argo_timeout\<close> (K 10.0)
 
 val timeout_seconds = seconds o Config.apply timeout
 
 fun with_timeout ctxt f x = Timeout.apply (timeout_seconds ctxt) f x
 
 
 (* extending the tactic *)
 
 type trans_context =
   Name.context * Argo_Expr.typ Typtab.table * (string * Argo_Expr.typ) Termtab.table
 
 type ('a, 'b) trans = 'a -> trans_context -> 'b * trans_context
 type ('a, 'b) trans' = 'a -> trans_context -> ('b * trans_context) option
 
 type extension = {
   trans_type: (typ, Argo_Expr.typ) trans -> (typ, Argo_Expr.typ) trans',
   trans_term: (term, Argo_Expr.expr) trans -> (term, Argo_Expr.expr) trans',
   term_of: (Argo_Expr.expr -> term) -> Argo_Expr.expr -> term option,
   replay_rewr: Proof.context -> Argo_Proof.rewrite -> conv,
   replay: (Argo_Expr.expr -> cterm) -> Proof.context -> Argo_Proof.rule -> thm list -> thm option}
 
 fun eq_extension ((serial1, _), (serial2, _)) = (serial1 = serial2)
 
 structure Extensions = Theory_Data
 (
   type T = (serial * extension) list
   val empty = []
   val extend = I
   val merge = merge eq_extension 
 )
 
 fun add_extension ext = Extensions.map (insert eq_extension (serial (), ext))
 fun get_extensions ctxt = Extensions.get (Proof_Context.theory_of ctxt)
 fun apply_first ctxt f = get_first (fn (_, e) => f e) (get_extensions ctxt)
 
 fun ext_trans sel ctxt f x tcx = apply_first ctxt (fn ext => sel ext f x tcx)
 
 val ext_trans_type = ext_trans (fn {trans_type, ...}: extension => trans_type)
 val ext_trans_term = ext_trans (fn {trans_term, ...}: extension => trans_term)
 
 fun ext_term_of ctxt f e = apply_first ctxt (fn {term_of, ...}: extension => term_of f e)
 
 fun ext_replay_rewr ctxt r = 
   get_extensions ctxt
   |> map (fn (_, {replay_rewr, ...}: extension) => replay_rewr ctxt r)
   |> Conv.first_conv
 
 fun ext_replay cprop_of ctxt rule prems =
   (case apply_first ctxt (fn {replay, ...}: extension => replay cprop_of ctxt rule prems) of
     SOME thm => thm
   | NONE => raise THM ("failed to replay " ^ quote (Argo_Proof.string_of_rule rule), 0, []))
 
 
 (* translating input terms *)
 
 fun add_new_type T (names, types, terms) =
   let
     val (n, names') = fresh_type_name T names
     val ty = Argo_Expr.Type n
   in (ty, (names', Typtab.update (T, ty) types, terms)) end
 
 fun add_type T (tcx as (_, types, _)) =
   (case Typtab.lookup types T of
     SOME ty => (ty, tcx)
   | NONE => add_new_type T tcx)
 
-fun trans_type _ \<^typ>\<open>HOL.bool\<close> = pair Argo_Expr.Bool
-  | trans_type ctxt (Type (\<^type_name>\<open>fun\<close>, [T1, T2])) =
+fun trans_type _ \<^Type>\<open>bool\<close> = pair Argo_Expr.Bool
+  | trans_type ctxt \<^Type>\<open>fun T1 T2\<close> =
       trans_type ctxt T1 ##>> trans_type ctxt T2 #>> Argo_Expr.Func
   | trans_type ctxt T = (fn tcx =>
       (case ext_trans_type ctxt (trans_type ctxt) T tcx of
         SOME result => result
       | NONE => add_type T tcx))
 
 fun add_new_term ctxt t T tcx =
   let
     val (ty, (names, types, terms)) = trans_type ctxt T tcx
     val (n, names') = fresh_term_name t names
     val c = (n, ty)
   in (Argo_Expr.mk_con c, (names', types, Termtab.update (t, c) terms)) end
 
 fun add_term ctxt t (tcx as (_, _, terms)) =
   (case Termtab.lookup terms t of
     SOME c => (Argo_Expr.mk_con c, tcx)
   | NONE => add_new_term ctxt t (Term.fastype_of t) tcx)
 
-fun mk_eq \<^typ>\<open>HOL.bool\<close> = Argo_Expr.mk_iff
+fun mk_eq \<^Type>\<open>bool\<close> = Argo_Expr.mk_iff
   | mk_eq _ = Argo_Expr.mk_eq
 
-fun trans_term _ \<^const>\<open>HOL.True\<close> = pair Argo_Expr.true_expr
-  | trans_term _ \<^const>\<open>HOL.False\<close> = pair Argo_Expr.false_expr
-  | trans_term ctxt (\<^const>\<open>HOL.Not\<close> $ t) = trans_term ctxt t #>> Argo_Expr.mk_not
-  | trans_term ctxt (\<^const>\<open>HOL.conj\<close> $ t1 $ t2) =
+fun trans_term _ \<^Const_>\<open>True\<close> = pair Argo_Expr.true_expr
+  | trans_term _ \<^Const_>\<open>False\<close> = pair Argo_Expr.false_expr
+  | trans_term ctxt \<^Const_>\<open>Not for t\<close> = trans_term ctxt t #>> Argo_Expr.mk_not
+  | trans_term ctxt \<^Const_>\<open>conj for t1 t2\<close> =
       trans_term ctxt t1 ##>> trans_term ctxt t2 #>> uncurry Argo_Expr.mk_and2
-  | trans_term ctxt (\<^const>\<open>HOL.disj\<close> $ t1 $ t2) =
+  | trans_term ctxt \<^Const_>\<open>disj for t1 t2\<close> =
       trans_term ctxt t1 ##>> trans_term ctxt t2 #>> uncurry Argo_Expr.mk_or2
-  | trans_term ctxt (\<^const>\<open>HOL.implies\<close> $ t1 $ t2) =
+  | trans_term ctxt \<^Const_>\<open>implies for t1 t2\<close> =
       trans_term ctxt t1 ##>> trans_term ctxt t2 #>> uncurry Argo_Expr.mk_imp
-  | trans_term ctxt (Const (\<^const_name>\<open>HOL.If\<close>, _) $ t1 $ t2 $ t3) =
+  | trans_term ctxt \<^Const_>\<open>If _ for t1 t2 t3\<close> =
       trans_term ctxt t1 ##>> trans_term ctxt t2 ##>> trans_term ctxt t3 #>>
       (fn ((u1, u2), u3) => Argo_Expr.mk_ite u1 u2 u3)
-  | trans_term ctxt (Const (\<^const_name>\<open>HOL.eq\<close>, T) $ t1 $ t2) =
-      trans_term ctxt t1 ##>> trans_term ctxt t2 #>> uncurry (mk_eq (Term.domain_type T))
+  | trans_term ctxt \<^Const_>\<open>HOL.eq T for t1 t2\<close> =
+      trans_term ctxt t1 ##>> trans_term ctxt t2 #>> uncurry (mk_eq T)
   | trans_term ctxt (t as (t1 $ t2)) = (fn tcx =>
       (case ext_trans_term ctxt (trans_term ctxt) t tcx of
         SOME result => result
       | NONE => tcx |> trans_term ctxt t1 ||>> trans_term ctxt t2 |>> uncurry Argo_Expr.mk_app))
   | trans_term ctxt t = (fn tcx =>
       (case ext_trans_term ctxt (trans_term ctxt) t tcx of
         SOME result => result
       | NONE => add_term ctxt t tcx))
 
 fun translate ctxt prop = trans_term ctxt (HOLogic.dest_Trueprop prop)
 
 
 (* invoking the solver *)
 
 type data = {
   names: Name.context,
   types: Argo_Expr.typ Typtab.table,
   terms: (string * Argo_Expr.typ) Termtab.table,
   argo: Argo_Solver.context}
 
 fun mk_data names types terms argo: data = {names=names, types=types, terms=terms, argo=argo}
 val empty_data = mk_data Name.context Typtab.empty Termtab.empty Argo_Solver.context
 
 structure Solver_Data = Proof_Data
 (
   type T = data option
   fun init _ = SOME empty_data
 )
 
 datatype ('m, 'p) solver_result = Model of 'm | Proof of 'p
 
 fun raw_solve es argo = Model (Argo_Solver.assert es argo)
   handle Argo_Proof.UNSAT proof => Proof proof
 
 fun value_of terms model t =
   (case Termtab.lookup terms t of
     SOME c => model c
   | _ => NONE)
 
 fun trace_props props ctxt =
   tracing ctxt (Pretty.string_of (Pretty.big_list "using these propositions:"
     (map (Syntax.pretty_term ctxt) props)))
 
 fun trace_result ctxt ({elapsed, ...}: Timing.timing) msg =
   tracing ctxt ("found a " ^ msg ^ " in " ^ string_of_int (Time.toMilliseconds elapsed) ^ " ms")
 
 fun solve props ctxt =
   (case Solver_Data.get ctxt of
     NONE => error "bad Argo solver context"
   | SOME {names, types, terms, argo} =>
       let
         val _ = with_tracing ctxt (trace_props props)
         val (es, (names', types', terms')) = fold_map (translate ctxt) props (names, types, terms)
         val _ = tracing ctxt "starting the prover"
       in
         (case Timing.timing (raw_solve es) argo of
           (time, Proof proof) =>
             let val _ = trace_result ctxt time "proof"
             in (Proof (terms', proof), Solver_Data.put NONE ctxt) end
         | (time, Model argo') =>
             let
               val _ = trace_result ctxt time "model"
               val model = value_of terms' (Argo_Solver.model_of argo')
             in (Model model, Solver_Data.put (SOME (mk_data names' types' terms' argo')) ctxt) end)
       end)
 
 
 (* reverse translation *)
 
 structure Contab = Table(type key = string * Argo_Expr.typ val ord = Argo_Expr.con_ord)
 
 fun mk_nary f ts = uncurry (fold_rev (curry f)) (split_last ts)
 
 fun mk_nary' d _ [] = d
   | mk_nary' _ f ts = mk_nary f ts
 
 fun mk_ite t1 t2 t3 =
-  let
-    val T = Term.fastype_of t2
-    val ite = Const (\<^const_name>\<open>HOL.If\<close>, [\<^typ>\<open>HOL.bool\<close>, T, T] ---> T)
-  in ite $ t1 $ t2 $ t3 end
+  let val T = Term.fastype_of t2
+  in \<^Const>\<open>If T for t1 t2 t3\<close> end
 
-fun term_of _ (Argo_Expr.E (Argo_Expr.True, _)) = \<^const>\<open>HOL.True\<close>
-  | term_of _ (Argo_Expr.E (Argo_Expr.False, _)) = \<^const>\<open>HOL.False\<close>
+fun term_of _ (Argo_Expr.E (Argo_Expr.True, _)) = \<^Const>\<open>True\<close>
+  | term_of _ (Argo_Expr.E (Argo_Expr.False, _)) = \<^Const>\<open>False\<close>
   | term_of cx (Argo_Expr.E (Argo_Expr.Not, [e])) = HOLogic.mk_not (term_of cx e)
   | term_of cx (Argo_Expr.E (Argo_Expr.And, es)) =
-      mk_nary' \<^const>\<open>HOL.True\<close> HOLogic.mk_conj (map (term_of cx) es)
+      mk_nary' \<^Const>\<open>True\<close> HOLogic.mk_conj (map (term_of cx) es)
   | term_of cx (Argo_Expr.E (Argo_Expr.Or, es)) =
-      mk_nary' \<^const>\<open>HOL.False\<close> HOLogic.mk_disj (map (term_of cx) es)
+      mk_nary' \<^Const>\<open>False\<close> HOLogic.mk_disj (map (term_of cx) es)
   | term_of cx (Argo_Expr.E (Argo_Expr.Imp, [e1, e2])) =
       HOLogic.mk_imp (term_of cx e1, term_of cx e2)
   | term_of cx (Argo_Expr.E (Argo_Expr.Iff, [e1, e2])) =
       HOLogic.mk_eq (term_of cx e1, term_of cx e2)
   | term_of cx (Argo_Expr.E (Argo_Expr.Ite, [e1, e2, e3])) =
       mk_ite (term_of cx e1) (term_of cx e2) (term_of cx e3)
   | term_of cx (Argo_Expr.E (Argo_Expr.Eq, [e1, e2])) =
       HOLogic.mk_eq (term_of cx e1, term_of cx e2)
   | term_of cx (Argo_Expr.E (Argo_Expr.App, [e1, e2])) =
       term_of cx e1 $ term_of cx e2
   | term_of (_, cons) (Argo_Expr.E (Argo_Expr.Con (c as (n, _)), _)) =
       (case Contab.lookup cons c of
         SOME t => t
       | NONE => error ("Unexpected expression named " ^ quote n))
   | term_of (cx as (ctxt, _)) e =
       (case ext_term_of ctxt (term_of cx) e of
         SOME t => t
       | NONE => raise Fail "bad expression")
 
-fun as_prop ct = Thm.apply \<^cterm>\<open>HOL.Trueprop\<close> ct
+fun as_prop ct = Thm.apply \<^cterm>\<open>Trueprop\<close> ct
 
 fun cterm_of ctxt cons e = Thm.cterm_of ctxt (term_of (ctxt, cons) e)
 fun cprop_of ctxt cons e = as_prop (cterm_of ctxt cons e)
 
 
 (* generic proof tools *)
 
 fun discharge thm rule = thm INCR_COMP rule
 fun discharge2 thm1 thm2 rule = discharge thm2 (discharge thm1 rule)
 fun discharges thm rules = [thm] RL rules
 
 fun under_assumption f ct =
   let val cprop = as_prop ct
   in Thm.implies_intr cprop (f (Thm.assume cprop)) end
 
 fun instantiate cv ct =
   Thm.instantiate (TVars.empty, Vars.make [(Term.dest_Var (Thm.term_of cv), ct)])
 
 
 (* proof replay for tautologies *)
 
 fun prove_taut ctxt ns t = Goal.prove ctxt ns [] (HOLogic.mk_Trueprop t)
   (fn {context, ...} => HEADGOAL (Classical.fast_tac context))
 
 fun with_frees ctxt n mk =
   let
     val ns = map (fn i => "P" ^ string_of_int i) (0 upto (n - 1))
-    val ts = map (Free o rpair \<^typ>\<open>bool\<close>) ns
+    val ts = map (Free o rpair \<^Type>\<open>bool\<close>) ns
     val t = mk_nary HOLogic.mk_disj (mk ts)
   in prove_taut ctxt ns t end
 
 fun taut_and1_term ts = mk_nary HOLogic.mk_conj ts :: map HOLogic.mk_not ts
 fun taut_and2_term i ts = [HOLogic.mk_not (mk_nary HOLogic.mk_conj ts), nth ts i]
 fun taut_or1_term i ts = [mk_nary HOLogic.mk_disj ts, HOLogic.mk_not (nth ts i)]
 fun taut_or2_term ts = HOLogic.mk_not (mk_nary HOLogic.mk_disj ts) :: ts
 
 val iff_1_taut = @{lemma "P = Q \<or> P \<or> Q" by fast}
 val iff_2_taut = @{lemma "P = Q \<or> (\<not>P) \<or> (\<not>Q)" by fast}
 val iff_3_taut = @{lemma "\<not>(P = Q) \<or> (\<not>P) \<or> Q" by fast}
 val iff_4_taut = @{lemma "\<not>(P = Q) \<or> P \<or> (\<not>Q)" by fast}
 val ite_then_taut = @{lemma "\<not>P \<or> (if P then t else u) = t" by auto}
 val ite_else_taut = @{lemma "P \<or> (if P then t else u) = u" by auto}
 
 fun taut_rule_of ctxt (Argo_Proof.Taut_And_1 n) = with_frees ctxt n taut_and1_term
   | taut_rule_of ctxt (Argo_Proof.Taut_And_2 (i, n)) = with_frees ctxt n (taut_and2_term i)
   | taut_rule_of ctxt (Argo_Proof.Taut_Or_1 (i, n)) = with_frees ctxt n (taut_or1_term i)
   | taut_rule_of ctxt (Argo_Proof.Taut_Or_2 n) = with_frees ctxt n taut_or2_term
   | taut_rule_of _ Argo_Proof.Taut_Iff_1 = iff_1_taut
   | taut_rule_of _ Argo_Proof.Taut_Iff_2 = iff_2_taut
   | taut_rule_of _ Argo_Proof.Taut_Iff_3 = iff_3_taut
   | taut_rule_of _ Argo_Proof.Taut_Iff_4 = iff_4_taut
   | taut_rule_of _ Argo_Proof.Taut_Ite_Then = ite_then_taut
   | taut_rule_of _ Argo_Proof.Taut_Ite_Else = ite_else_taut
 
 fun replay_taut ctxt k ct =
   let val rule = taut_rule_of ctxt k
   in Thm.instantiate (Thm.match (Thm.cprop_of rule, ct)) rule end
 
 
 (* proof replay for conjunct extraction *)
 
 fun replay_conjunct 0 1 thm = thm
   | replay_conjunct 0 _ thm = discharge thm @{thm conjunct1}
   | replay_conjunct 1 2 thm = discharge thm @{thm conjunct2}
   | replay_conjunct i n thm = replay_conjunct (i - 1) (n - 1) (discharge thm @{thm conjunct2})
 
 
 (* proof replay for rewrite steps *)
 
 fun mk_rewr thm = thm RS @{thm eq_reflection}
 
 fun not_nary_conv rule i ct =
   if i > 1 then (Conv.rewr_conv rule then_conv Conv.arg_conv (not_nary_conv rule (i - 1))) ct
   else Conv.all_conv ct
 
 val flatten_and_thm = @{lemma "(P1 \<and> P2) \<and> P3 \<equiv> P1 \<and> P2 \<and> P3" by simp}
 val flatten_or_thm = @{lemma "(P1 \<or> P2) \<or> P3 \<equiv> P1 \<or> P2 \<or> P3" by simp}
 
 fun flatten_conv cv rule ct = (
   Conv.try_conv (Conv.arg_conv cv) then_conv
   Conv.try_conv (Conv.rewr_conv rule then_conv cv)) ct
 
 fun flat_conj_conv ct =
   (case Thm.term_of ct of
-    \<^const>\<open>HOL.conj\<close> $ _ $ _ => flatten_conv flat_conj_conv flatten_and_thm ct
+    \<^Const_>\<open>conj for _ _\<close> => flatten_conv flat_conj_conv flatten_and_thm ct
   | _ => Conv.all_conv ct)
 
 fun flat_disj_conv ct =
   (case Thm.term_of ct of
-    \<^const>\<open>HOL.disj\<close> $ _ $ _ => flatten_conv flat_disj_conv flatten_or_thm ct
+    \<^Const_>\<open>disj for _ _\<close> => flatten_conv flat_disj_conv flatten_or_thm ct
   | _ => Conv.all_conv ct)
 
 fun explode rule1 rule2 thm =
   explode rule1 rule2 (thm RS rule1) @ explode rule1 rule2 (thm RS rule2) handle THM _ => [thm]
 val explode_conj = explode @{thm conjunct1} @{thm conjunct2}
 val explode_ndis = explode @{lemma "\<not>(P \<or> Q) \<Longrightarrow> \<not>P" by auto} @{lemma "\<not>(P \<or> Q) \<Longrightarrow> \<not>Q" by auto}
 
 fun pick_false i thms = nth thms i
 
 fun pick_dual rule (i1, i2) thms =
   rule OF [nth thms i1, nth thms i2] handle THM _ => rule OF [nth thms i2, nth thms i1]
 val pick_dual_conj = pick_dual @{lemma "\<not>P \<Longrightarrow> P \<Longrightarrow> False" by auto}
 val pick_dual_ndis = pick_dual @{lemma "\<not>P \<Longrightarrow> P \<Longrightarrow> \<not>True" by auto}
 
 fun join thm0 rule is thms =
   let
     val l = length thms
     val thms' = fold (fn i => cons (if 0 <= i andalso i < l then nth thms i else thm0)) is []
   in fold (fn thm => fn thm' => discharge2 thm thm' rule) (tl thms') (hd thms') end
 
 val join_conj = join @{lemma "True" by auto} @{lemma "P \<Longrightarrow> Q \<Longrightarrow> P \<and> Q" by auto}
 val join_ndis = join @{lemma "\<not>False" by auto} @{lemma "\<not>P \<Longrightarrow> \<not>Q \<Longrightarrow> \<not>(P \<or> Q)" by auto}
 
 val false_thm = @{lemma "False \<Longrightarrow> P" by auto}
 val ntrue_thm = @{lemma "\<not>True \<Longrightarrow> P" by auto}
 val iff_conj_thm = @{lemma "(P \<Longrightarrow> Q) \<Longrightarrow> (Q \<Longrightarrow> P) \<Longrightarrow> P = Q" by auto}
 val iff_ndis_thm = @{lemma "(\<not>P \<Longrightarrow> \<not>Q) \<Longrightarrow> (\<not>Q \<Longrightarrow> \<not>P) \<Longrightarrow> P = Q" by auto}
 
 fun iff_intro rule lf rf ct =
   let
     val lhs = under_assumption lf ct
     val rhs = rf (Thm.dest_arg (snd (Thm.dest_implies (Thm.cprop_of lhs))))
   in mk_rewr (discharge2 lhs rhs rule) end
 
 fun with_conj f g ct = iff_intro iff_conj_thm (f o explode_conj) g ct
-fun with_ndis f g ct = iff_intro iff_ndis_thm (f o explode_ndis) g (Thm.apply \<^cterm>\<open>HOL.Not\<close> ct)
+fun with_ndis f g ct = iff_intro iff_ndis_thm (f o explode_ndis) g (Thm.apply \<^cterm>\<open>Not\<close> ct)
 
 fun swap_indices n iss = map (fn i => find_index (fn is => member (op =) is i) iss) (0 upto (n - 1))
 fun sort_nary w f g (n, iss) = w (f (map hd iss)) (under_assumption (f (swap_indices n iss) o g))
 val sort_conj = sort_nary with_conj join_conj explode_conj
 val sort_ndis = sort_nary with_ndis join_ndis explode_ndis 
 
 val not_true_thm = mk_rewr @{lemma "(\<not>True) = False" by auto}
 val not_false_thm = mk_rewr @{lemma "(\<not>False) = True" by auto}
 val not_not_thm = mk_rewr @{lemma "(\<not>\<not>P) = P" by auto}
 val not_and_thm = mk_rewr @{lemma "(\<not>(P \<and> Q)) = (\<not>P \<or> \<not>Q)" by auto}
 val not_or_thm = mk_rewr @{lemma "(\<not>(P \<or> Q)) = (\<not>P \<and> \<not>Q)" by auto}
 val not_iff_thms = map mk_rewr
   @{lemma "(\<not>((\<not>P) = Q)) = (P = Q)" "(\<not>(P = (\<not>Q))) = (P = Q)" "(\<not>(P = Q)) = ((\<not>P) = Q)" by auto}
 val iff_true_thms = map mk_rewr @{lemma "(True = P) = P" "(P = True) = P" by auto}
 val iff_false_thms = map mk_rewr @{lemma "(False = P) = (\<not>P)" "(P = False) = (\<not>P)" by auto}
 val iff_not_not_thm = mk_rewr @{lemma "((\<not>P) = (\<not>Q)) = (P = Q)" by auto}
 val iff_refl_thm = mk_rewr @{lemma "(P = P) = True" by auto}
 val iff_symm_thm = mk_rewr @{lemma "(P = Q) = (Q = P)" by auto}
 val iff_dual_thms = map mk_rewr @{lemma "(P = (\<not>P)) = False" "((\<not>P) = P) = False" by auto}
 val imp_thm = mk_rewr @{lemma "(P \<longrightarrow> Q) = (\<not>P \<or> Q)" by auto}
 val ite_prop_thm = mk_rewr @{lemma "(If P Q R) = ((\<not>P \<or> Q) \<and> (P \<or> R) \<and> (Q \<or> R))" by auto}
 val ite_true_thm = mk_rewr @{lemma "(If True t u) = t" by auto}
 val ite_false_thm = mk_rewr @{lemma "(If False t u) = u" by auto}
 val ite_eq_thm = mk_rewr @{lemma "(If P t t) = t" by auto}
 val eq_refl_thm = mk_rewr @{lemma "(t = t) = True" by auto}
 val eq_symm_thm = mk_rewr @{lemma "(t1 = t2) = (t2 = t1)" by auto}
 
 fun replay_rewr _ Argo_Proof.Rewr_Not_True = Conv.rewr_conv not_true_thm
   | replay_rewr _ Argo_Proof.Rewr_Not_False = Conv.rewr_conv not_false_thm
   | replay_rewr _ Argo_Proof.Rewr_Not_Not = Conv.rewr_conv not_not_thm
   | replay_rewr _ (Argo_Proof.Rewr_Not_And i) = not_nary_conv not_and_thm i
   | replay_rewr _ (Argo_Proof.Rewr_Not_Or i) = not_nary_conv not_or_thm i
   | replay_rewr _ Argo_Proof.Rewr_Not_Iff = Conv.rewrs_conv not_iff_thms
   | replay_rewr _ (Argo_Proof.Rewr_And_False i) = with_conj (pick_false i) (K false_thm)
   | replay_rewr _ (Argo_Proof.Rewr_And_Dual ip) = with_conj (pick_dual_conj ip) (K false_thm)
   | replay_rewr _ (Argo_Proof.Rewr_And_Sort is) = flat_conj_conv then_conv sort_conj is
   | replay_rewr _ (Argo_Proof.Rewr_Or_True i) = with_ndis (pick_false i) (K ntrue_thm)
   | replay_rewr _ (Argo_Proof.Rewr_Or_Dual ip) = with_ndis (pick_dual_ndis ip) (K ntrue_thm)
   | replay_rewr _ (Argo_Proof.Rewr_Or_Sort is) = flat_disj_conv then_conv sort_ndis is
   | replay_rewr _ Argo_Proof.Rewr_Iff_True = Conv.rewrs_conv iff_true_thms
   | replay_rewr _ Argo_Proof.Rewr_Iff_False = Conv.rewrs_conv iff_false_thms
   | replay_rewr _ Argo_Proof.Rewr_Iff_Not_Not = Conv.rewr_conv iff_not_not_thm
   | replay_rewr _ Argo_Proof.Rewr_Iff_Refl = Conv.rewr_conv iff_refl_thm
   | replay_rewr _ Argo_Proof.Rewr_Iff_Symm = Conv.rewr_conv iff_symm_thm
   | replay_rewr _ Argo_Proof.Rewr_Iff_Dual  = Conv.rewrs_conv iff_dual_thms
   | replay_rewr _ Argo_Proof.Rewr_Imp = Conv.rewr_conv imp_thm
   | replay_rewr _ Argo_Proof.Rewr_Ite_Prop = Conv.rewr_conv ite_prop_thm
   | replay_rewr _ Argo_Proof.Rewr_Ite_True = Conv.rewr_conv ite_true_thm
   | replay_rewr _ Argo_Proof.Rewr_Ite_False = Conv.rewr_conv ite_false_thm
   | replay_rewr _ Argo_Proof.Rewr_Ite_Eq = Conv.rewr_conv ite_eq_thm
   | replay_rewr _ Argo_Proof.Rewr_Eq_Refl = Conv.rewr_conv eq_refl_thm
   | replay_rewr _ Argo_Proof.Rewr_Eq_Symm = Conv.rewr_conv eq_symm_thm
   | replay_rewr ctxt r = ext_replay_rewr ctxt r
 
 fun binop_conv cv1 cv2 = Conv.combination_conv (Conv.arg_conv cv1) cv2
 
 fun replay_conv _ Argo_Proof.Keep_Conv ct = Conv.all_conv ct
   | replay_conv ctxt (Argo_Proof.Then_Conv (c1, c2)) ct = 
       (replay_conv ctxt c1 then_conv replay_conv ctxt c2) ct
   | replay_conv ctxt (Argo_Proof.Args_Conv (Argo_Expr.App, [c1, c2])) ct =
       Conv.combination_conv (replay_conv ctxt c1) (replay_conv ctxt c2) ct
   | replay_conv ctxt (Argo_Proof.Args_Conv (_, cs)) ct = replay_args_conv ctxt cs ct
   | replay_conv ctxt (Argo_Proof.Rewr_Conv r) ct = replay_rewr ctxt r ct
 
 and replay_args_conv _ [] ct = Conv.all_conv ct
   | replay_args_conv ctxt [c] ct = Conv.arg_conv (replay_conv ctxt c) ct
   | replay_args_conv ctxt [c1, c2] ct = binop_conv (replay_conv ctxt c1) (replay_conv ctxt c2) ct
   | replay_args_conv ctxt (c :: cs) ct =
       (case Term.head_of (Thm.term_of ct) of
-        Const (\<^const_name>\<open>HOL.If\<close>, _) =>
+        \<^Const_>\<open>If _\<close> =>
           let val (cs', c') = split_last cs
           in Conv.combination_conv (replay_args_conv ctxt (c :: cs')) (replay_conv ctxt c') ct end
       | _ => binop_conv (replay_conv ctxt c) (replay_args_conv ctxt cs) ct)
 
 fun replay_rewrite ctxt c thm = Conv.fconv_rule (HOLogic.Trueprop_conv (replay_conv ctxt c)) thm
 
 
 (* proof replay for clauses *)
 
 val prep_clause_rule = @{lemma "P \<Longrightarrow> \<not>P \<Longrightarrow> False" by fast}
 val extract_lit_rule = @{lemma "(\<not>(P \<or> Q) \<Longrightarrow> False) \<Longrightarrow> \<not>P \<Longrightarrow> \<not>Q \<Longrightarrow> False" by fast}
 
 fun add_lit i thm lits =
   let val ct = Thm.cprem_of thm 1
   in (Thm.implies_elim thm (Thm.assume ct), (i, ct) :: lits) end
 
 fun extract_lits [] _ = error "Bad clause"
   | extract_lits [i] (thm, lits) = add_lit i thm lits
   | extract_lits (i :: is) (thm, lits) =
       extract_lits is (add_lit i (discharge thm extract_lit_rule) lits)
 
 fun lit_ord ((l1, _), (l2, _)) = int_ord (abs l1, abs l2)
 
 fun replay_with_lits [] thm lits = (thm, lits)
   | replay_with_lits is thm lits =
       extract_lits is (discharge thm prep_clause_rule, lits)
       ||> Ord_List.make lit_ord
 
 fun replay_clause is thm = replay_with_lits is thm []
 
 
 (* proof replay for unit resolution *)
 
 val unit_rule = @{lemma "(P \<Longrightarrow> False) \<Longrightarrow> (\<not>P \<Longrightarrow> False) \<Longrightarrow> False" by fast}
 val unit_rule_var = Thm.dest_arg (Thm.dest_arg1 (Thm.cprem_of unit_rule 1))
-val bogus_ct = \<^cterm>\<open>HOL.True\<close>
+val bogus_ct = \<^cterm>\<open>True\<close>
 
 fun replay_unit_res lit (pthm, plits) (nthm, nlits) =
   let
     val plit = the (AList.lookup (op =) plits lit)
     val nlit = the (AList.lookup (op =) nlits (~lit))
     val prune = Ord_List.remove lit_ord (lit, bogus_ct)
   in
     unit_rule
     |> instantiate unit_rule_var (Thm.dest_arg plit)
     |> Thm.elim_implies (Thm.implies_intr plit pthm)
     |> Thm.elim_implies (Thm.implies_intr nlit nthm)
     |> rpair (Ord_List.union lit_ord (prune nlits) (prune plits))
   end
 
 
 (* proof replay for hypothesis *)
 
 val dneg_rule = @{lemma "\<not>\<not>P \<Longrightarrow> P" by auto}
 
 fun replay_hyp i ct =
   if i < 0 then (Thm.assume ct, [(~i, ct)])
   else
-    let val cu = as_prop (Thm.apply \<^cterm>\<open>HOL.Not\<close> (Thm.apply \<^cterm>\<open>HOL.Not\<close> (Thm.dest_arg ct)))
+    let val cu = as_prop (Thm.apply \<^cterm>\<open>Not\<close> (Thm.apply \<^cterm>\<open>Not\<close> (Thm.dest_arg ct)))
     in (discharge (Thm.assume cu) dneg_rule, [(~i, cu)]) end
 
 
 (* proof replay for lemma *)
 
 fun replay_lemma is (thm, lits) = replay_with_lits is thm lits
 
 
 (* proof replay for reflexivity *)
 
 val refl_rule = @{thm refl}
 val refl_rule_var = Thm.dest_arg1 (Thm.dest_arg (Thm.cprop_of refl_rule))
 
 fun replay_refl ct = Thm.instantiate (Thm.match (refl_rule_var, ct)) refl_rule
 
 
 (* proof replay for symmetry *)
 
 val symm_rules = @{lemma "a = b ==> b = a" "\<not>(a = b) \<Longrightarrow> \<not>(b = a)" by simp_all}
 
 fun replay_symm thm = hd (discharges thm symm_rules)
 
 
 (* proof replay for transitivity *)
 
 val trans_rules = @{lemma
   "\<not>(a = b) \<Longrightarrow> b = c \<Longrightarrow> \<not>(a = c)"
   "a = b \<Longrightarrow> \<not>(b = c) \<Longrightarrow> \<not>(a = c)"
   "a = b \<Longrightarrow> b = c ==> a = c"
   by simp_all}
 
 fun replay_trans thm1 thm2 = hd (discharges thm2 (discharges thm1 trans_rules))
 
 
 (* proof replay for congruence *)
 
 fun replay_cong thm1 thm2 = discharge thm2 (discharge thm1 @{thm cong})
 
 
 (* proof replay for substitution *)
 
 val subst_rule1 = @{lemma "\<not>(p a) \<Longrightarrow> p = q \<Longrightarrow> a = b \<Longrightarrow> \<not>(q b)" by simp}
 val subst_rule2 = @{lemma "p a \<Longrightarrow> p = q \<Longrightarrow> a = b \<Longrightarrow> q b" by simp}
 
 fun replay_subst thm1 thm2 thm3 =
   subst_rule1 OF [thm1, thm2, thm3] handle THM _ => subst_rule2 OF [thm1, thm2, thm3]
 
 
 (* proof replay *)
 
 structure Thm_Cache = Table(type key = Argo_Proof.proof_id val ord = Argo_Proof.proof_id_ord)
 
 val unclausify_rule1 = @{lemma "(\<not>P \<Longrightarrow> False) \<Longrightarrow> P" by auto}
 val unclausify_rule2 = @{lemma "(P \<Longrightarrow> False) \<Longrightarrow> \<not>P" by auto}
 
 fun unclausify (thm, lits) ls =
   (case (Thm.prop_of thm, lits) of
-    (\<^const>\<open>HOL.Trueprop\<close> $ \<^const>\<open>HOL.False\<close>, [(_, ct)]) =>
+    (\<^Const_>\<open>Trueprop for \<open>\<^Const_>\<open>False\<close>\<close>\<close>, [(_, ct)]) =>
       let val thm = Thm.implies_intr ct thm
       in (discharge thm unclausify_rule1 handle THM _ => discharge thm unclausify_rule2, ls) end
   | _ => (thm, Ord_List.union lit_ord lits ls))
 
 fun with_thms f tps = fold_map unclausify tps [] |>> f
 
 fun bad_premises () = raise Fail "bad number of premises"
 fun with_thms1 f = with_thms (fn [thm] => f thm | _ => bad_premises ())
 fun with_thms2 f = with_thms (fn [thm1, thm2] => f thm1 thm2 | _ => bad_premises ())
 fun with_thms3 f = with_thms (fn [thm1, thm2, thm3] => f thm1 thm2 thm3 | _ => bad_premises ())
 
 fun replay_rule (ctxt, cons, facts) prems rule =
   (case rule of
     Argo_Proof.Axiom i => (nth facts i, [])
   | Argo_Proof.Taut (k, concl) => (replay_taut ctxt k (cprop_of ctxt cons concl), [])
   | Argo_Proof.Conjunct (i, n) => with_thms1 (replay_conjunct i n) prems
   | Argo_Proof.Rewrite c => with_thms1 (replay_rewrite ctxt c) prems
   | Argo_Proof.Clause is => replay_clause is (fst (hd prems))
   | Argo_Proof.Unit_Res i => replay_unit_res i (hd prems) (hd (tl prems))
   | Argo_Proof.Hyp (i, concl) => replay_hyp i (cprop_of ctxt cons concl)
   | Argo_Proof.Lemma is => replay_lemma is (hd prems)
   | Argo_Proof.Refl concl => (replay_refl (cterm_of ctxt cons concl), [])
   | Argo_Proof.Symm => with_thms1 replay_symm prems
   | Argo_Proof.Trans => with_thms2 replay_trans prems
   | Argo_Proof.Cong => with_thms2 replay_cong prems
   | Argo_Proof.Subst => with_thms3 replay_subst prems
   | _ => with_thms (ext_replay (cprop_of ctxt cons) ctxt rule) prems)
 
 fun with_cache f proof thm_cache =
   (case Thm_Cache.lookup thm_cache (Argo_Proof.id_of proof) of
     SOME thm => (thm, thm_cache)
   | NONE =>
       let val (thm, thm_cache') = f proof thm_cache
       in (thm, Thm_Cache.update (Argo_Proof.id_of proof, thm) thm_cache') end)
 
 fun trace_step ctxt proof_id rule proofs = with_full_tracing ctxt (fn ctxt' =>
   let
     val id = Argo_Proof.string_of_proof_id proof_id
     val ids = map (Argo_Proof.string_of_proof_id o Argo_Proof.id_of) proofs
     val rule_string = Argo_Proof.string_of_rule rule
   in full_tracing ctxt' ("  " ^ id ^ " <- " ^ space_implode " " ids ^ " . " ^ rule_string) end)
 
 fun replay_bottom_up (env as (ctxt, _, _)) proof thm_cache =
   let
     val (proof_id, rule, proofs) = Argo_Proof.dest proof
     val (prems, thm_cache) = fold_map (with_cache (replay_bottom_up env)) proofs thm_cache
     val _ = trace_step ctxt proof_id rule proofs
   in (replay_rule env prems rule, thm_cache) end
 
 fun replay_proof env proof = with_cache (replay_bottom_up env) proof Thm_Cache.empty
 
 fun replay ctxt terms facts proof =
   let
     val env = (ctxt, Termtab.fold (Contab.update o swap) terms Contab.empty, facts)
     val _ = tracing ctxt "replaying the proof"
     val ({elapsed=t, ...}, ((thm, _), _)) = Timing.timing (replay_proof env) proof
     val _ = tracing ctxt ("replayed the proof in " ^ string_of_int (Time.toMilliseconds t) ^ " ms")
   in thm end
 
 
 (* normalizing goals *)
 
 fun instantiate_elim_rule thm =
   let val ct = Drule.strip_imp_concl (Thm.cprop_of thm)
   in
     (case Thm.term_of ct of
-      \<^const>\<open>HOL.Trueprop\<close> $ Var (_, \<^typ>\<open>HOL.bool\<close>) =>
-        instantiate (Thm.dest_arg ct) \<^cterm>\<open>HOL.False\<close> thm
-    | Var _ => instantiate ct \<^cprop>\<open>HOL.False\<close> thm
+      \<^Const_>\<open>Trueprop for \<open>Var (_, \<^Type>\<open>bool\<close>)\<close>\<close> =>
+        instantiate (Thm.dest_arg ct) \<^cterm>\<open>False\<close> thm
+    | Var _ => instantiate ct \<^cprop>\<open>False\<close> thm
     | _ => thm)
   end
 
 fun atomize_conv ctxt ct =
   (case Thm.term_of ct of
-    \<^const>\<open>HOL.Trueprop\<close> $ _ => Conv.all_conv
-  | \<^const>\<open>Pure.imp\<close> $ _ $ _ =>
+    \<^Const_>\<open>Trueprop for _\<close> => Conv.all_conv
+  | \<^Const_>\<open>Pure.imp for _ _\<close> =>
       Conv.binop_conv (atomize_conv ctxt) then_conv
       Conv.rewr_conv @{thm atomize_imp}
-  | Const (\<^const_name>\<open>Pure.eq\<close>, _) $ _ $ _ =>
+  | \<^Const>\<open>Pure.eq _ for _ _\<close> =>
       Conv.binop_conv (atomize_conv ctxt) then_conv
       Conv.rewr_conv @{thm atomize_eq}
-  | Const (\<^const_name>\<open>Pure.all\<close>, _) $ Abs _ =>
+  | \<^Const>\<open>Pure.all _ for \<open>Abs _\<close>\<close> =>
       Conv.binder_conv (atomize_conv o snd) ctxt then_conv
       Conv.rewr_conv @{thm atomize_all}
   | _ => Conv.all_conv) ct
 
 fun normalize ctxt thm =
   thm
   |> instantiate_elim_rule
   |> Conv.fconv_rule (Thm.beta_conversion true then_conv Thm.eta_conversion)
   |> Thm.forall_intr_vars
   |> Conv.fconv_rule (atomize_conv ctxt)
 
 
 (* prover, tactic and method *)
 
 datatype result = Satisfiable of term -> bool option | Unsatisfiable
 
 fun check props ctxt =
   (case solve props ctxt of
     (Proof _, ctxt') => (Unsatisfiable, ctxt')
   | (Model model, ctxt') => (Satisfiable model, ctxt'))
 
 fun prove thms ctxt =
   let val thms' = map (normalize ctxt) thms
   in
     (case solve (map Thm.prop_of thms') ctxt of
       (Model _, ctxt') => (NONE, ctxt')
     | (Proof (terms, proof), ctxt') => (SOME (replay ctxt' terms thms' proof), ctxt'))
   end
 
 fun argo_tac ctxt thms =
   CONVERSION (Conv.params_conv ~1 (K (Conv.concl_conv ~1
     (Conv.try_conv (Conv.rewr_conv @{thm atomize_eq})))) ctxt)
   THEN' Tactic.resolve_tac ctxt [@{thm ccontr}]
   THEN' Subgoal.FOCUS (fn {context, prems, ...} =>
     (case with_timeout context (prove (thms @ prems)) context of
       (SOME thm, _) => Tactic.resolve_tac context [thm] 1
     | (NONE, _) => Tactical.no_tac)) ctxt
 
 val _ =
   Theory.setup (Method.setup \<^binding>\<open>argo\<close>
     (Scan.optional Attrib.thms [] >>
       (fn thms => fn ctxt => METHOD (fn facts =>
         HEADGOAL (argo_tac ctxt (thms @ facts)))))
     "Applies the Argo prover")
 
 end