diff --git a/thys/Poincare_Bendixson/Affine_Arithmetic_Misc.thy b/thys/Poincare_Bendixson/Affine_Arithmetic_Misc.thy
--- a/thys/Poincare_Bendixson/Affine_Arithmetic_Misc.thy
+++ b/thys/Poincare_Bendixson/Affine_Arithmetic_Misc.thy
@@ -1,148 +1,147 @@
 theory Affine_Arithmetic_Misc
   imports "HOL-ODE-Numerics.ODE_Numerics"
 begin
 
-
 section \<open>Branch-And-Bound Arithmetic\<close>
 
 primrec prove_nonneg::"(nat * nat * string) list \<Rightarrow> nat \<Rightarrow> nat \<Rightarrow> slp \<Rightarrow> real aform list list \<Rightarrow> bool" where
   "prove_nonneg prnt 0 p slp X = (let _ = if prnt \<noteq> [] then print (STR ''# depth limit exceeded\<newline>'') else () in False)"
 | "prove_nonneg prnt (Suc i) p slp XXS =
     (case XXS of [] \<Rightarrow> True | (X#XS) \<Rightarrow>
       let RS = approx_slp_outer p 1 slp X
       in if RS\<noteq>None \<and> Inf_aform' p (hd (the RS)) \<ge> 0
         then
           let _ = if prnt \<noteq> [] then print (STR ''# Success\<newline>'') else ();
              _ = if prnt \<noteq> [] then print (String.implode ((shows ''# '' o shows_box_of_aforms_hr X) ''\<newline>'')) else ();
              _ = fold (\<lambda>(a, b, c) _. print (String.implode (shows_segments_of_aform a b X c ''\<newline>''))) prnt ()
           in prove_nonneg prnt i p slp XS
         else let _ = if prnt \<noteq> [] then print (STR ''# Split\<newline>'') else () in case split_aforms_largest_uncond X of (a, b) \<Rightarrow>
           prove_nonneg prnt i p slp (a#b#XS))"
 
 lemma prove_nonneg_simps[simp]:
   "prove_nonneg prnt 0 p slp X = False"
   "prove_nonneg prnt (Suc i) p slp XXS =
     (case XXS of [] \<Rightarrow> True | (X#XS) \<Rightarrow>
       let RS = approx_slp_outer p 1 slp X
       in if RS\<noteq>None \<and> Inf_aform' p (hd (the RS)) \<ge> 0
         then prove_nonneg prnt i p slp XS
         else case split_aforms_largest_uncond X of (a, b) \<Rightarrow> prove_nonneg prnt i p slp (a#b#XS))"
   by (auto simp: Let_def split: if_splits option.splits list.splits)
 
 lemmas [simp del] = prove_nonneg.simps
 
 lemma split_aforms_lemma:
   fixes xs::"real list"
   assumes "split_aforms XS i = (YS, ZS)"
   assumes "xs \<in> Joints XS"
   shows "xs \<in> Joints YS \<union> Joints ZS"
   using set_rev_mp[OF assms(2) Joints_map_split_aform[of XS i]] assms(1)
   by (auto simp: split_aforms_def o_def)
 
 lemma prove_nonneg_empty[simp]: "prove_nonneg prnt (Suc i) p slp []"
   by simp
 
 lemma prove_nonneg_fuel_mono:
   "prove_nonneg prnt (Suc i) p (slp_of_fas [fa]) YSS"
   if "prove_nonneg prnt i p (slp_of_fas [fa]) YSS"
   using that
 proof (induction i arbitrary: YSS)
   case 0
   then show ?case by simp
 next
   case (Suc i)
   from Suc.prems show ?case
     supply [simp del] = prove_nonneg_simps
     apply (subst prove_nonneg_simps)
     apply (auto simp: Let_def split: if_splits option.splits list.splits)
     subgoal apply (rule Suc.IH)
       apply (subst (asm) prove_nonneg_simps)
       by (auto simp: Let_def split: if_splits option.splits list.splits)
     subgoal apply (rule Suc.IH)
       apply (subst (asm) prove_nonneg.simps)
       by (auto simp: Let_def split: if_splits option.splits list.splits)
     subgoal apply (rule Suc.IH)
       apply (subst (asm) prove_nonneg.simps)
       by (auto simp: Let_def split: if_splits option.splits list.splits)
     done
 qed
 
 lemma prove_nonneg_mono:
   "prove_nonneg prnt i p (slp_of_fas [fa]) YSS" if "prove_nonneg prnt i p (slp_of_fas [fa]) (YS # YSS)"
   using that
 proof (induction i arbitrary: YS YSS)
   case 0
   then show ?case by auto
 next
   case (Suc i)
   from Suc.prems show ?case
     supply [simp del] = prove_nonneg_simps
     apply (subst (asm) prove_nonneg_simps)
     apply (auto simp: Let_def split: if_splits option.splits list.splits)
     subgoal by (rule prove_nonneg_fuel_mono)
     subgoal for x y apply (rule prove_nonneg_fuel_mono)
       apply (rule Suc.IH[of y])
       by (rule Suc.IH[of x])
     subgoal for x y apply (rule prove_nonneg_fuel_mono)
       apply (rule Suc.IH[of y])
       by (rule Suc.IH[of x])
     done
 qed
 
 lemma prove_nonneg:
   assumes "prove_nonneg prnt i p (slp_of_fas [fa]) XSS"
   shows "\<forall>XS \<in> set XSS. \<forall>xs \<in> Joints XS. interpret_floatarith fa xs \<ge> 0"
   using assms
 proof (induction i arbitrary: XSS)
   case 0
   then show ?case
     by (auto )
 next
   case (Suc i)
   show ?case
   proof (cases XSS)
     case Nil then show ?thesis by auto
   next
     case (Cons YS YSS)
     show ?thesis
       unfolding Cons
       apply auto
       subgoal for xs using Suc.prems
         apply (auto simp: Cons Let_def split: if_splits option.splits)
         subgoal for ys
           apply (drule approx_slp_outer_plain)
              apply (rule refl)
             apply force
            apply assumption
           apply simp
           apply (frule Joints_imp_length_eq[where XS=ys])
           apply (auto simp: Suc_length_conv)
           by (smt Inf_aform'_Affine_le)
         subgoal
           apply (simp add: split_aforms_largest_uncond_def split: prod.splits)
           apply (drule Suc.IH)
           apply (drule split_aforms_lemma, assumption)
           by auto
         subgoal
           apply (simp add: split_aforms_largest_uncond_def split: prod.splits)
           apply (drule Suc.IH)
           apply (drule split_aforms_lemma, assumption)
           by auto
         done
       subgoal for XS xs using Suc.prems
         apply (auto simp: Cons Let_def split: if_splits option.splits)
         subgoal for ys by (rule Suc.IH[rule_format], assumption, assumption, assumption)
         subgoal for ys
           apply (drule prove_nonneg_mono)
           apply (drule prove_nonneg_mono)
           by (rule Suc.IH[rule_format], assumption, assumption, assumption)
         subgoal for ys
           apply (drule prove_nonneg_mono)
           apply (drule prove_nonneg_mono)
           by (rule Suc.IH[rule_format], assumption, assumption, assumption)
         done
       done
   qed
 qed
 
 end
\ No newline at end of file
diff --git a/thys/Poincare_Bendixson/Analysis_Misc.thy b/thys/Poincare_Bendixson/Analysis_Misc.thy
--- a/thys/Poincare_Bendixson/Analysis_Misc.thy
+++ b/thys/Poincare_Bendixson/Analysis_Misc.thy
@@ -1,1134 +1,1135 @@
 section \<open>Additions to HOL-Analysis\<close>
 theory Analysis_Misc
   imports 
     Ordinary_Differential_Equations.ODE_Analysis
 begin
 
 subsection \<open>Unsorted Lemmas (TODO: sort!)\<close>
 
 lemma uminus_uminus_image: "uminus ` uminus ` S = S"
   for S::"'r::ab_group_add set"
   by (auto simp: image_image)
 
 lemma in_uminus_image_iff[simp]: "x \<in> uminus ` S \<longleftrightarrow> - x \<in> S"
   for S::"'r::ab_group_add set"
   by force
 
 lemma closed_subsegmentI:
   "w + t *\<^sub>R (z - w) \<in> {x--y}"
   if "w \<in> {x -- y}" "z \<in> {x -- y}" and t: "0 \<le> t" "t\<le> 1"
 proof -
   from that obtain u v where
     w_def: "w = (1 - u) *\<^sub>R x + u *\<^sub>R y" and u: "0 \<le> u" "u \<le> 1"
     and z_def: "z = (1 - v) *\<^sub>R x + v *\<^sub>R y" and v: "0 \<le> v" "v \<le> 1"
     by (auto simp: in_segment)
   have "w + t *\<^sub>R (z - w) =
     (1 - (u - t * (u - v))) *\<^sub>R x + (u - t * (u - v)) *\<^sub>R y"
     by (simp add: algebra_simps w_def z_def)
   also have "\<dots> \<in> {x -- y}"
-    apply (rule closed_segmentI[OF _ refl])
-    using t u v 
+    unfolding closed_segment_image_interval
+    apply (rule imageI)
+    using t u v
     apply auto
      apply (metis (full_types) diff_0_right diff_left_mono linear mult_left_le_one_le mult_nonneg_nonpos order.trans)
     by (smt mult_left_le_one_le mult_nonneg_nonneg vector_space_over_itself.scale_right_diff_distrib)
   finally show ?thesis .
 qed
 
 lemma tendsto_minus_cancel_right: "((\<lambda>x. -g x) \<longlongrightarrow> l) F \<longleftrightarrow> (g \<longlongrightarrow> -l) F"
   \<comment> \<open>cf @{thm tendsto_minus_cancel_left}\<close>
   for g::"_ \<Rightarrow> 'b::topological_group_add"
   by (simp add: tendsto_minus_cancel_left)
 
 lemma tendsto_nhds_continuousI: "(f \<longlongrightarrow> l) (nhds x)" if "(f \<longlongrightarrow> l) (at x)" "f x = l"
   \<comment> \<open>TODO: the assumption is continuity of f at x\<close>
 proof (rule topological_tendstoI)
   fix S::"'b set" assume "open S" "l \<in> S"
   from topological_tendstoD[OF that(1) this]
   have "\<forall>\<^sub>F x in at x. f x \<in> S" .
   then show "\<forall>\<^sub>F x in nhds x. f x \<in> S"
     unfolding eventually_at_filter
     by eventually_elim (auto simp: that \<open>l \<in> S\<close>)
 qed
 
 lemma inj_composeD:
   assumes "inj (\<lambda>x. g (t x))"
   shows "inj t"
   using assms
   by (auto simp: inj_def)
 
 lemma compact_sequentialE:
   fixes S T::"'a::first_countable_topology set"
   assumes "compact S"
   assumes "infinite T"
   assumes "T \<subseteq> S"
   obtains t::"nat \<Rightarrow> 'a" and l::'a
   where "\<And>n. t n \<in> T" "\<And>n. t n \<noteq> l" "t \<longlonglongrightarrow> l" "l \<in> S"
 proof -
   from Heine_Borel_imp_Bolzano_Weierstrass[OF assms]
   obtain l where "l \<in> S" "l islimpt T" by metis
   then obtain t where "t n \<in> T" "t n \<noteq> l" "t \<longlonglongrightarrow> l" "l \<in> S" for n unfolding islimpt_sequential
     by auto
   then show ?thesis ..
 qed
 
 lemma infinite_countable_subsetE:
   fixes S::"'a set"
   assumes "infinite S"
   obtains g::"nat\<Rightarrow>'a" where "inj g" "range g \<subseteq> S"
   using assms
   by atomize_elim (simp add: infinite_countable_subset)
 
 lemma real_quad_ge: "2 * (an * bn) \<le> an * an + bn * bn" for an bn::real
   by (sos "(((A<0 * R<1) + (R<1 * (R<1 * [an + ~1*bn]^2))))")
 
 lemma inner_quad_ge: "2 * (a \<bullet> b) \<le> a \<bullet> a + b \<bullet> b"
   for a b::"'a::euclidean_space"\<comment> \<open>generalize?\<close>
 proof -
   show ?thesis
     by (subst (1 2 3) euclidean_inner)
       (auto simp add: sum.distrib[symmetric] sum_distrib_left intro!: sum_mono real_quad_ge)
 qed
 
 lemma inner_quad_gt: "2 * (a \<bullet> b) < a \<bullet> a + b \<bullet> b"
   if "a \<noteq> b"
   for a b::"'a::euclidean_space"\<comment> \<open>generalize?\<close>
 proof -
   from that obtain i where "i \<in> Basis" "a \<bullet> i \<noteq> b \<bullet> i"
     by (auto simp: euclidean_eq_iff[where 'a='a])
   then have "2 * (a \<bullet> i * (b \<bullet> i)) < a \<bullet> i * (a \<bullet> i) + b \<bullet> i * (b \<bullet> i)"
     using sum_sqs_eq[of "a\<bullet>i" "b\<bullet>i"]
     by (auto intro!: le_neq_trans real_quad_ge)
   then show ?thesis
     by (subst (1 2 3) euclidean_inner)
       (auto simp add: \<open>i \<in> Basis\<close> sum.distrib[symmetric] sum_distrib_left
         intro!: sum_strict_mono_ex1 real_quad_ge)
 qed
 
 lemma closed_segment_line_hyperplanes:
   "{a -- b} = range (\<lambda>u. a + u *\<^sub>R (b - a)) \<inter> {x. a \<bullet> (b - a) \<le> x \<bullet> (b - a) \<and> x \<bullet> (b - a) \<le> b \<bullet> (b - a)}"
   if "a \<noteq> b"
   for a b::"'a::euclidean_space"
 proof safe
   fix x assume x: "x \<in> {a--b}"
   then obtain u where u: "0 \<le> u" "u \<le> 1" and x_eq: "x = a + u *\<^sub>R (b - a)"
     by (auto simp add: in_segment algebra_simps)
   show "x \<in> range (\<lambda>u. a + u *\<^sub>R (b - a))" using x_eq by auto
   have "2 * (a \<bullet> b) \<le> a \<bullet> a + b \<bullet> b"
     by (rule inner_quad_ge)
   then have "u * (2 * (a \<bullet> b) - a \<bullet> a - b \<bullet> b) \<le> 0"
     "0 \<le> (1 - u) * (a \<bullet> a + b \<bullet> b - a \<bullet> b * 2)"
     by (simp_all add: mult_le_0_iff u)
   then show " a \<bullet> (b - a) \<le> x \<bullet> (b - a)" "x \<bullet> (b - a) \<le> b \<bullet> (b - a)"
     by (auto simp: x_eq algebra_simps power2_eq_square inner_commute)
 next
   fix u assume
     "a \<bullet> (b - a) \<le> (a + u *\<^sub>R (b - a)) \<bullet> (b - a)"
     "(a + u *\<^sub>R (b - a)) \<bullet> (b - a) \<le> b \<bullet> (b - a)"
   then have "0 \<le> u * ((b - a) \<bullet> (b - a))" "0 \<le> (1 - u) * ((b - a) \<bullet> (b - a))"
     by (auto simp: algebra_simps)
   then have "0 \<le> u" "u \<le> 1"
     using inner_ge_zero[of "(b - a)"] that
     by (auto simp add: zero_le_mult_iff)
   then show "a + u *\<^sub>R (b - a) \<in> {a--b}"
     by (auto simp: in_segment algebra_simps)
 qed
 
 lemma open_segment_line_hyperplanes:
   "{a <--< b} = range (\<lambda>u. a + u *\<^sub>R (b - a)) \<inter> {x. a \<bullet> (b - a) < x \<bullet> (b - a) \<and> x \<bullet> (b - a) < b \<bullet> (b - a)}"
   if "a \<noteq> b"
   for a b::"'a::euclidean_space"
 proof safe
   fix x assume x: "x \<in> {a<--<b}"
   then obtain u where u: "0 < u" "u < 1" and x_eq: "x = a + u *\<^sub>R (b - a)"
     by (auto simp add: in_segment algebra_simps)
   show "x \<in> range (\<lambda>u. a + u *\<^sub>R (b - a))" using x_eq by auto
   have "2 * (a \<bullet> b) < a \<bullet> a + b \<bullet> b" using that
     by (rule inner_quad_gt)
   then have "u * (2 * (a \<bullet> b) - a \<bullet> a - b \<bullet> b) < 0"
     "0 < (1 - u) * (a \<bullet> a + b \<bullet> b - a \<bullet> b * 2)"
     by (simp_all add: mult_less_0_iff u)
   then show " a \<bullet> (b - a) < x \<bullet> (b - a)" "x \<bullet> (b - a) < b \<bullet> (b - a)"
     by (auto simp: x_eq algebra_simps power2_eq_square inner_commute)
 next
   fix u assume
     "a \<bullet> (b - a) < (a + u *\<^sub>R (b - a)) \<bullet> (b - a)"
     "(a + u *\<^sub>R (b - a)) \<bullet> (b - a) < b \<bullet> (b - a)"
   then have "0 < u * ((b - a) \<bullet> (b - a))" "0 < (1 - u) * ((b - a) \<bullet> (b - a))"
     by (auto simp: algebra_simps)
   then have "0 < u" "u < 1"
     using inner_ge_zero[of "(b - a)"] that
     by (auto simp add: zero_less_mult_iff)
   then show "a + u *\<^sub>R (b - a) \<in> {a<--<b}"
     by (auto simp: in_segment algebra_simps that)
 qed
 
 lemma at_within_interior: "NO_MATCH UNIV S \<Longrightarrow> x \<in> interior S \<Longrightarrow> at x within S = at x"
   by (auto intro: at_within_interior)
 
 lemma tendsto_at_topI:
   "(f \<longlongrightarrow> l) at_top" if "\<And>e. 0 < e \<Longrightarrow> \<exists>x0. \<forall>x\<ge>x0. dist (f x) l < e"
 for f::"'a::linorder_topology \<Rightarrow> 'b::metric_space"
   using that
   apply (intro tendstoI)
   unfolding eventually_at_top_linorder
   by auto
 
 lemma tendsto_at_topE:
   fixes f::"'a::linorder_topology \<Rightarrow> 'b::metric_space"
   assumes "(f \<longlongrightarrow> l) at_top"
   assumes "e > 0"
   obtains x0 where "\<And>x. x \<ge> x0 \<Longrightarrow> dist (f x) l < e"
 proof -
   from assms(1)[THEN tendstoD, OF assms(2)]
   have "\<forall>\<^sub>F x in at_top. dist (f x) l < e" .
   then show ?thesis
     unfolding eventually_at_top_linorder
     by (auto intro: that)
 qed
 lemma tendsto_at_top_iff: "(f \<longlongrightarrow> l) at_top \<longleftrightarrow> (\<forall>e>0. \<exists>x0. \<forall>x\<ge>x0. dist (f x) l < e)"
   for f::"'a::linorder_topology \<Rightarrow> 'b::metric_space"
   by (auto intro!: tendsto_at_topI elim!: tendsto_at_topE)
 
 lemma tendsto_at_top_eq_left:
   fixes f g::"'a::linorder_topology \<Rightarrow> 'b::metric_space"
   assumes "(f \<longlongrightarrow> l) at_top"
   assumes "\<And>x. x \<ge> x0 \<Longrightarrow> f x = g x"
   shows "(g \<longlongrightarrow> l) at_top"
   unfolding tendsto_at_top_iff
   by (metis (no_types, hide_lams) assms(1) assms(2) linear order_trans tendsto_at_topE)
 
 lemma lim_divide_n: "(\<lambda>x. e / real x) \<longlonglongrightarrow> 0"
 proof -
   have "(\<lambda>x. e * inverse (real x)) \<longlonglongrightarrow> 0"
     by (auto intro: tendsto_eq_intros lim_inverse_n)
   then show ?thesis by (simp add: inverse_eq_divide)
 qed
 
 definition at_top_within :: "('a::order) set \<Rightarrow> 'a filter"
   where "at_top_within s = (INF k \<in> s. principal ({k ..} \<inter> s)) "
 
 lemma at_top_within_at_top[simp]:
   shows "at_top_within UNIV = at_top"
   unfolding at_top_within_def at_top_def
   by (auto)
 
 lemma at_top_within_empty[simp]:
   shows "at_top_within {} = top"
   unfolding at_top_within_def
   by (auto)
 
 definition "nhds_set X = (INF S\<in>{S. open S \<and> X \<subseteq> S}. principal S)"
 
 lemma eventually_nhds_set:
   "(\<forall>\<^sub>F x in nhds_set X. P x) \<longleftrightarrow> (\<exists>S. open S \<and> X \<subseteq> S \<and> (\<forall>x\<in>S. P x))"
   unfolding nhds_set_def by (subst eventually_INF_base) (auto simp: eventually_principal)
 
 term "filterlim f (nhds_set (frontier X)) F" \<comment> \<open>f tends to the boundary of X?\<close>
 
 
 text \<open>somewhat inspired by @{thm islimpt_range_imp_convergent_subsequence} and its dependencies.
 The class constraints seem somewhat arbitrary, perhaps this can be generalized in some way.
 \<close>
 lemma limpt_closed_imp_exploding_subsequence:\<comment>\<open>TODO: improve name?!\<close>
   fixes f::"'a::{heine_borel,real_normed_vector} \<Rightarrow> 'b::{first_countable_topology, t2_space}"
   assumes cont[THEN continuous_on_compose2, continuous_intros]: "continuous_on T f"
   assumes closed: "closed T"
   assumes bound: "\<And>t. t \<in> T \<Longrightarrow> f t \<noteq> l"
   assumes limpt: "l islimpt (f ` T)"
   obtains s where
     "(f \<circ> s) \<longlonglongrightarrow> l"
     "\<And>i. s i \<in> T"
     "\<And>C. compact C \<Longrightarrow> C \<subseteq> T \<Longrightarrow> \<forall>\<^sub>F i in sequentially. s i \<notin> C"
 proof -
   from countable_basis_at_decseq[of l]
   obtain A where A: "\<And>i. open (A i)" "\<And>i. l \<in> A i"
     and evA: "\<And>S. open S \<Longrightarrow> l \<in> S \<Longrightarrow> eventually (\<lambda>i. A i \<subseteq> S) sequentially"
     by blast
 
   from closed_Union_compact_subsets[OF closed]
   obtain C
     where C: "(\<And>n. compact (C n))" "(\<And>n. C n \<subseteq> T)" "(\<And>n. C n \<subseteq> C (Suc n))" "\<Union> (range C) = T"
       and evC: "(\<And>K. compact K \<Longrightarrow> K \<subseteq> T \<Longrightarrow> \<forall>\<^sub>F i in sequentially. K \<subseteq> C i)"
     by (metis eventually_sequentially)
 
   have AC: "l \<in> A i - f ` C i" "open (A i - f ` C i)" for i
     using C bound
     by (fastforce intro!: open_Diff A compact_imp_closed compact_continuous_image continuous_intros)+
 
   from islimptE[OF limpt AC] have "\<exists>t\<in>T. f t \<in> A i - f ` C i \<and> f t \<noteq> l" for i by blast  
   then obtain t where t: "\<And>i. t i \<in> T" "\<And>i. f (t i) \<in> A i - f ` C i" "\<And>i. f (t i) \<noteq> l"
     by metis
 
   have "(f o t) \<longlonglongrightarrow> l"
     using t
     by (auto intro!: topological_tendstoI dest!: evA elim!: eventually_mono)
   moreover
   have "\<And>i. t i \<in> T" by fact
   moreover
   have "\<forall>\<^sub>F i in sequentially. t i \<notin> K" if "compact K" "K \<subseteq> T" for K
     using evC[OF that]
     by eventually_elim (use t in auto)
   ultimately show ?thesis ..
 qed  
 
 lemma Inf_islimpt: "bdd_below S \<Longrightarrow> Inf S \<notin> S \<Longrightarrow> S \<noteq> {} \<Longrightarrow> Inf S islimpt S" for S::"real set"
   by (auto simp: islimpt_in_closure intro!: closure_contains_Inf)
 
 context linorder
 begin
 
 text \<open>HOL-analysis doesn't seem to have these, maybe they were never needed.
   Some variants are around @{thm Int_atLeastAtMost}, but with old-style naming conventions.
   Change to the "modern" I.. convention there?\<close>
 
 lemma Int_Ico[simp]:
   shows "{a..} \<inter> {b..} = {max a b ..}"
   by (auto)
 
 lemma Int_Ici_Ico[simp]:
   shows "{a..} \<inter> {b..<c} = {max a b ..<c}"
   by auto
 
 lemma Int_Ico_Ici[simp]:
   shows "{a..<c} \<inter> {b..} = {max a b ..<c}"
   by auto
 
 lemma subset_Ico_iff[simp]:
   "{a..<b} \<subseteq> {c..<b} \<longleftrightarrow> b \<le> a \<or> c \<le> a"
   unfolding atLeastLessThan_def
   by auto
 
 lemma Ico_subset_Ioo_iff[simp]:
   "{a..<b} \<subseteq> {c<..<b} \<longleftrightarrow> b \<le> a \<or> c < a"
   unfolding greaterThanLessThan_def atLeastLessThan_def
   by auto
 
 lemma Icc_Un_Ici[simp]:
   shows "{a..b} \<union> {b..} = {min a b..}"
   unfolding atLeastAtMost_def atLeast_def atMost_def min_def
   by auto
 
 end
 
 lemma at_top_within_at_top_unbounded_right:
   fixes a::"'a::linorder"
   shows "at_top_within {a..} = at_top"
   unfolding at_top_within_def at_top_def
   apply (auto intro!: INF_eq)
   by (metis linorder_class.linear linorder_class.max.cobounded1 linorder_class.max.idem ord_class.atLeast_iff)
 
 lemma at_top_within_at_top_unbounded_rightI:
   fixes a::"'a::linorder"
   assumes "{a..} \<subseteq> s"
   shows "at_top_within s = at_top"
   unfolding at_top_within_def at_top_def
   apply (auto intro!: INF_eq)
    apply (meson Ici_subset_Ioi_iff Ioi_le_Ico assms dual_order.refl dual_order.trans leI)
   by (metis assms atLeast_iff atLeast_subset_iff inf.cobounded1 linear subsetD)
 
 lemma at_top_within_at_top_bounded_right:
   fixes a b::"'a::{dense_order,linorder_topology}"
   assumes "a < b"
   shows "at_top_within {a..<b} = at_left b"
   unfolding at_top_within_def at_left_eq[OF assms(1)]
   apply (auto intro!: INF_eq)
    apply (smt atLeastLessThan_iff greaterThanLessThan_iff le_less lessThan_iff max.absorb1 subset_eq)
   by (metis assms atLeastLessThan_iff dense linear max.absorb1 not_less order_trans)
 
 lemma at_top_within_at_top_bounded_right':
   fixes a b::"'a::{dense_order,linorder_topology}"
   assumes "a < b"
   shows "at_top_within {..<b} = at_left b"
   unfolding at_top_within_def at_left_eq[OF assms(1)]
   apply (auto intro!: INF_eq)
    apply (meson atLeast_iff greaterThanLessThan_iff le_less lessThan_iff subset_eq)
   by (metis Ico_subset_Ioo_iff atLeastLessThan_def dense lessThan_iff)
 
 lemma eventually_at_top_within_linorder:
   assumes sn:"s \<noteq> {}"
   shows "eventually P (at_top_within s) \<longleftrightarrow> (\<exists>x0::'a::{linorder_topology} \<in> s. \<forall>x \<ge> x0. x\<in> s \<longrightarrow> P x)"
   unfolding at_top_within_def
   apply (subst eventually_INF_base)
     apply (auto simp:eventually_principal sn)
   by (metis atLeast_subset_iff inf.coboundedI2 inf_commute linear)
 
 lemma tendsto_at_top_withinI:
   fixes f::"'a::linorder_topology \<Rightarrow> 'b::metric_space"
   assumes "s \<noteq> {}"
   assumes "\<And>e. 0 < e \<Longrightarrow> \<exists>x0 \<in> s. \<forall>x \<in> {x0..} \<inter> s. dist (f x) l < e"
   shows  "(f \<longlongrightarrow> l) (at_top_within s)"
   apply(intro tendstoI)
   unfolding at_top_within_def apply (subst eventually_INF_base)
     apply (auto simp:eventually_principal assms)
   by (metis atLeast_subset_iff inf.coboundedI2 inf_commute linear)
 
 lemma tendsto_at_top_withinE:
   fixes f::"'a::linorder_topology \<Rightarrow> 'b::metric_space"
   assumes "s \<noteq> {}"
   assumes "(f \<longlongrightarrow> l) (at_top_within s)"
   assumes "e > 0"
   obtains x0 where "x0 \<in> s" "\<And>x. x \<in> {x0..} \<inter> s \<Longrightarrow> dist (f x) l < e"
 proof -
   from assms(2)[THEN tendstoD, OF assms(3)]
   have "\<forall>\<^sub>F x in at_top_within s. dist (f x) l < e" .
   then show ?thesis unfolding eventually_at_top_within_linorder[OF \<open>s \<noteq> {}\<close>] 
     by (auto intro: that)
 qed
 
 lemma tendsto_at_top_within_iff:
   fixes f::"'a::linorder_topology \<Rightarrow> 'b::metric_space"
   assumes "s \<noteq> {}"
   shows "(f \<longlongrightarrow> l) (at_top_within s) \<longleftrightarrow> (\<forall>e>0. \<exists>x0 \<in> s. \<forall>x \<in> {x0..} \<inter> s. dist (f x) l < e)"
   by (auto intro!: tendsto_at_top_withinI[OF \<open>s \<noteq> {}\<close>] elim!: tendsto_at_top_withinE[OF \<open>s \<noteq> {}\<close>])
 
 lemma filterlim_at_top_at_top_within_bounded_right:
   fixes a b::"'a::{dense_order,linorder_topology}"
   fixes f::"'a \<Rightarrow> real"
   assumes "a < b"
   shows "filterlim f at_top (at_top_within {..<b}) = (f \<longlongrightarrow> \<infinity>) (at_left b)"
   unfolding filterlim_at_top_dense
     at_top_within_at_top_bounded_right'[OF assms(1)]
     eventually_at_left[OF assms(1)]
     tendsto_PInfty
   by auto
 
 text \<open>Extract a sequence (going to infinity) bounded away from l\<close>
 
 lemma not_tendsto_frequentlyE:
   assumes "\<not>((f \<longlongrightarrow> l) F)"
   obtains S where "open S" "l \<in> S" "\<exists>\<^sub>F x in F. f x \<notin> S"
   using assms
   by (auto simp: tendsto_def not_eventually)
 
 lemma not_tendsto_frequently_metricE:
   assumes "\<not>((f \<longlongrightarrow> l) F)"
   obtains e where "e > 0" "\<exists>\<^sub>F x in F. e \<le> dist (f x) l"
   using assms
   by (auto simp: tendsto_iff not_eventually not_less)
 
 lemma eventually_frequently_conj: "frequently P F \<Longrightarrow> eventually Q F \<Longrightarrow> frequently (\<lambda>x. P x \<and> Q x) F"
   unfolding frequently_def
   apply (erule contrapos_nn)
   subgoal premises prems
     using prems by eventually_elim auto
   done
 
 lemma frequently_at_top:
   "(\<exists>\<^sub>F t in at_top. P t) \<longleftrightarrow> (\<forall>t0. \<exists>t>t0. P t)"
   for P::"'a::{linorder,no_top}\<Rightarrow>bool" 
   by (auto simp: frequently_def eventually_at_top_dense)
 
 lemma frequently_at_topE:
   fixes P::"nat \<Rightarrow> 'a::{linorder,no_top}\<Rightarrow>_"
   assumes freq[rule_format]: "\<forall>n. \<exists>\<^sub>F a in at_top. P n a"
   obtains s::"nat\<Rightarrow>'a"
   where "\<And>i. P i (s i)" "strict_mono s"
 proof -
   have "\<exists>f. \<forall>n. P n (f n) \<and> f n < f (Suc n)"
   proof (rule dependent_nat_choice)
     from frequently_ex[OF freq[of 0]] show "\<exists>x. P 0 x" .
     fix x n assume "P n x"
     from freq[unfolded frequently_at_top, rule_format, of x "Suc n"]
     obtain y where "P (Suc n) y" "y > x" by auto
     then show "\<exists>y. P (Suc n) y \<and> x < y"
       by auto
   qed
   then obtain s where "\<And>i. P i (s i)" "strict_mono s"
     unfolding strict_mono_Suc_iff by auto
   then show ?thesis ..
 qed
 
 lemma frequently_at_topE':
   fixes P::"nat \<Rightarrow> 'a::{linorder,no_top}\<Rightarrow>_"
   assumes freq[rule_format]: "\<forall>n. \<exists>\<^sub>F a in at_top. P n a"
     and g: "filterlim g at_top sequentially"
   obtains s::"nat\<Rightarrow>'a"
   where "\<And>i. P i (s i)" "strict_mono s" "\<And>n. g n \<le> s n"
 proof -
   have "\<forall>n. \<exists>\<^sub>F a in at_top. P n a \<and> g n \<le> a"
     using freq
     by (auto intro!: eventually_frequently_conj)
   from frequently_at_topE[OF this] obtain s where "\<And>i. P i (s i)" "strict_mono s" "\<And>n. g n \<le> s n"
     by metis
   then show ?thesis ..
 qed
 
 lemma frequently_at_top_at_topE:
   fixes P::"nat \<Rightarrow> 'a::{linorder,no_top}\<Rightarrow>_" and g::"nat\<Rightarrow>'a"
   assumes "\<forall>n. \<exists>\<^sub>F a in at_top. P n a" "filterlim g at_top sequentially"
   obtains s::"nat\<Rightarrow>'a"
   where "\<And>i. P i (s i)" "filterlim s at_top sequentially"
 proof -
   from frequently_at_topE'[OF assms]
   obtain s where s: "(\<And>i. P i (s i))" "strict_mono s" "(\<And>n. g n \<le> s n)" by blast
   have s_at_top: "filterlim s at_top sequentially"
     by (rule filterlim_at_top_mono) (use assms s in auto)
   with s(1) show ?thesis ..
 qed
 
 (* Extract a strict monotone and sequence converging to something other than l *)
 lemma not_tendsto_convergent_seq:
   fixes f::"real \<Rightarrow> 'a::metric_space"
   assumes X: "compact (X::'a set)"
   assumes im: "\<And>x. x \<ge> 0 \<Longrightarrow> f x \<in> X"
   assumes nl: "\<not> ((f \<longlongrightarrow> (l::'a)) at_top)"
   obtains s k where
     "k \<in> X" "k \<noteq> l" "(f \<circ> s) \<longlonglongrightarrow> k" "strict_mono s" "\<forall>n. s n \<ge> n"
 proof -
   from not_tendsto_frequentlyE[OF nl]
   obtain S where "open S" "l \<in> S" "\<exists>\<^sub>F x in at_top. f x \<notin> S" .
   have "\<forall>n. \<exists>\<^sub>F x in at_top. f x \<notin> S \<and> real n \<le> x"
     apply (rule allI)
     apply (rule eventually_frequently_conj)
      apply fact
     by (rule eventually_ge_at_top)
   from frequently_at_topE[OF this]
   obtain s where "\<And>i. f (s i) \<notin> S" and s: "strict_mono s" and s_ge: "(\<And>i. real i \<le> s i)" by metis
   then have "0 \<le> s i" for i using dual_order.trans of_nat_0_le_iff by blast
   then have "\<forall>n. (f \<circ> s) n \<in> X" using im by auto
   from X[unfolded compact_def, THEN spec, THEN mp, OF this]
   obtain k r where k: "k \<in> X" and r: "strict_mono r" and kLim: "(f \<circ> s \<circ> r) \<longlonglongrightarrow> k" by metis
   have "k \<in> X - S"
     by (rule Lim_in_closed_set[of "X - S", OF _ _ _ kLim])
       (auto simp: im \<open>0 \<le> s _\<close>  \<open>\<And>i. f (s i) \<notin> S\<close> intro!: \<open>open S\<close> X intro: compact_imp_closed)
 
   note k
   moreover have "k \<noteq> l" using \<open>k \<in> X - S\<close> \<open>l \<in> S\<close> by auto
   moreover have "(f \<circ> (s \<circ> r)) \<longlonglongrightarrow> k" using kLim by (simp add: o_assoc)
   moreover have "strict_mono (s \<circ> r)" using s r by (rule strict_mono_o)
   moreover have "\<forall>n. (s \<circ> r) n \<ge> n" using s_ge r
     by (metis comp_apply dual_order.trans of_nat_le_iff seq_suble)
   ultimately show ?thesis ..
 qed
 
 lemma harmonic_bound:
   shows "1 / 2 ^(Suc n) < 1 / real (Suc n)"
 proof (induction n)
   case 0
   then show ?case by auto
 next
   case (Suc n)
   then show ?case
     by (smt frac_less2 of_nat_0_less_iff of_nat_less_two_power zero_less_Suc)
 qed
 
 lemma INF_bounded_imp_convergent_seq:
   fixes f::"real \<Rightarrow> real"
   assumes cont: "continuous_on {a..} f"
   assumes bound: "\<And>t. t \<ge> a \<Longrightarrow> f t > l"
   assumes inf: "(INF t\<in>{a..}. f t) = l"
   obtains s where
     "(f \<circ> s) \<longlonglongrightarrow> l"
     "\<And>i. s i \<in> {a..}"
     "filterlim s at_top sequentially"
 proof -
   have bound': "t \<in> {a..} \<Longrightarrow> f t \<noteq> l" for t using bound[of t] by auto
   have limpt: "l islimpt f ` {a..}"
   proof -
     have "Inf (f ` {a..}) islimpt f ` {a..}"
       by (rule Inf_islimpt) (auto simp: inf intro!: bdd_belowI2[where m=l] dest: bound)
     then show ?thesis by (simp add: inf)
   qed
   from limpt_closed_imp_exploding_subsequence[OF cont closed_atLeast bound' limpt]
   obtain s where s: "(f \<circ> s) \<longlonglongrightarrow> l"
     "\<And>i. s i \<in> {a..}"
     "compact C \<Longrightarrow> C \<subseteq> {a..} \<Longrightarrow> \<forall>\<^sub>F i in sequentially. s i \<notin> C" for C
     by metis
   have "\<forall>\<^sub>F i in sequentially. s i \<ge> n" for n
     using s(3)[of "{a..n}"] s(2)
     by (auto elim!: eventually_mono)
   then have "filterlim s at_top sequentially"
     unfolding filterlim_at_top
     by auto
   from s(1) s(2) this
   show ?thesis ..
 qed
 
 (* Generalizes to other combinations of strict_mono and filterlim *)
 lemma filterlim_at_top_strict_mono:
   fixes s :: "_ \<Rightarrow> 'a::linorder"
   fixes r :: "nat \<Rightarrow> _"
   assumes "strict_mono s"
   assumes "strict_mono r"
   assumes "filterlim s at_top F"
   shows "filterlim (s \<circ> r) at_top F"
   apply (rule filterlim_at_top_mono[OF assms(3)])
   by (simp add: assms(1) assms(2) seq_suble strict_mono_leD)
 
 lemma LIMSEQ_lb:
   assumes fl: "s \<longlonglongrightarrow> (l::real)"
   assumes u: "l < u"
   shows "\<exists>n0. \<forall>n\<ge>n0. s n < u"
 proof -
   from fl have "\<exists>no>0. \<forall>n\<ge>no. dist (s n) l < u-l" unfolding LIMSEQ_iff_nz using u
     by simp
   thus ?thesis using dist_real_def by fastforce
 qed
 
 (* Used to sharpen a tendsto with additional information*)
 lemma filterlim_at_top_choose_lower:
   assumes "filterlim s at_top sequentially"
   assumes "(f \<circ> s) \<longlonglongrightarrow> l"
   obtains t where
     "filterlim t at_top sequentially"
     "(f \<circ> t) \<longlonglongrightarrow> l"
     "\<forall>n. t n \<ge> (b::real)"
 proof -
   obtain k where k: "\<forall>n \<ge> k. s n \<ge> b" using assms(1)
     unfolding filterlim_at_top eventually_sequentially by blast
   define t where "t = (\<lambda>n. s (n+k))"
   then have "\<forall>n. t n \<ge> b" using k by simp
   have "filterlim t at_top sequentially" using assms(1)
     unfolding filterlim_at_top eventually_sequentially t_def
     by (metis (full_types) add.commute trans_le_add2)
   from LIMSEQ_ignore_initial_segment[OF assms(2), of "k"]
   have "(\<lambda>n. (f \<circ> s) (n + k)) \<longlonglongrightarrow> l" .
   then have "(f \<circ> t) \<longlonglongrightarrow> l" unfolding t_def o_def by simp
   show ?thesis
     using \<open>(f \<circ> t) \<longlonglongrightarrow> l\<close> \<open>\<forall>n. b \<le> t n\<close> \<open>filterlim t at_top sequentially\<close> that by blast
 qed
 
 lemma frequently_at_top_realE:
   fixes P::"nat \<Rightarrow> real \<Rightarrow> bool"
   assumes "\<forall>n. \<exists>\<^sub>F t in at_top. P n t"
   obtains s::"nat\<Rightarrow>real"
   where "\<And>i. P i (s i)" "filterlim s at_top at_top"
   by (metis assms frequently_at_top_at_topE[OF _ filterlim_real_sequentially])
 
 lemma approachable_sequenceE:
   fixes f::"real \<Rightarrow> 'a::metric_space"
   assumes "\<And>t e. 0 \<le> t \<Longrightarrow> 0 < e \<Longrightarrow> \<exists>tt\<ge>t. dist (f tt) p < e"
   obtains s where "filterlim s at_top sequentially" "(f \<circ> s) \<longlonglongrightarrow> p"
 proof -
   have "\<forall>n. \<exists>\<^sub>F i in at_top. dist (f i) p < 1/real (Suc n)"
     unfolding frequently_at_top
     apply (auto )
     subgoal for n m
       using assms[of "max 0 (m+1)" "1/(Suc n)"]
       by force
     done
   from frequently_at_top_realE[OF this]
   obtain s where s: "\<And>i. dist (f (s i)) p < 1 / real (Suc i)" "filterlim s at_top sequentially"
     by metis
   note this(2)
   moreover
   have "(f o s) \<longlonglongrightarrow> p"
   proof (rule tendstoI)
     fix e::real assume "e > 0"
     have "\<forall>\<^sub>F i in sequentially. 1 / real (Suc i) < e"
       apply (rule order_tendstoD[OF _ \<open>0 < e\<close>])
       apply (rule real_tendsto_divide_at_top)
        apply (rule tendsto_intros)
       by (rule filterlim_compose[OF filterlim_real_sequentially filterlim_Suc])
     then show "\<forall>\<^sub>F x in sequentially. dist ((f \<circ> s) x) p < e"
       by eventually_elim (use dual_order.strict_trans s \<open>e > 0\<close> in auto)
   qed
   ultimately show ?thesis ..
 qed
 
 lemma mono_inc_bdd_above_has_limit_at_topI:
   fixes f::"real \<Rightarrow> real"
   assumes "mono f"
   assumes "\<And>x. f x \<le> u"
   shows "\<exists>l. (f \<longlongrightarrow> l) at_top"
 proof -
   define l where "l = Sup (range (\<lambda>n. f (real n)))"
   have t:"(\<lambda>n. f (real n)) \<longlonglongrightarrow> l" unfolding l_def
     apply (rule LIMSEQ_incseq_SUP)
      apply (meson assms(2) bdd_aboveI2)
     by (meson assms(1) mono_def of_nat_mono)
   from tendsto_at_topI_sequentially_real[OF assms(1) t]
   have "(f \<longlongrightarrow> l) at_top" .
   thus ?thesis by blast  
 qed
 
 lemma gen_mono_inc_bdd_above_has_limit_at_topI:
   fixes f::"real \<Rightarrow> real"
   assumes "\<And>x y. x \<ge> b \<Longrightarrow> x \<le> y \<Longrightarrow> f x \<le> f y"
   assumes "\<And>x. x \<ge> b \<Longrightarrow> f x \<le> u"
   shows "\<exists>l. (f \<longlongrightarrow> l) at_top"
 proof -
   define ff where "ff = (\<lambda>x. if x \<ge> b then f x else f b)"
   have m1:"mono ff" unfolding ff_def mono_def using assms(1) by simp
   have m2:"\<And>x. ff x \<le> u" unfolding ff_def using assms(2) by simp
   from mono_inc_bdd_above_has_limit_at_topI[OF m1 m2]
   obtain l where "(ff \<longlongrightarrow> l) at_top" by blast
   thus ?thesis
     by (meson \<open>(ff \<longlongrightarrow> l) at_top\<close> ff_def tendsto_at_top_eq_left)
 qed
 
 lemma gen_mono_dec_bdd_below_has_limit_at_topI:
   fixes f::"real \<Rightarrow> real"
   assumes "\<And>x y. x \<ge> b \<Longrightarrow> x \<le> y \<Longrightarrow> f x \<ge> f y"
   assumes "\<And>x. x \<ge> b \<Longrightarrow> f x \<ge> u"
   shows "\<exists>l. (f \<longlongrightarrow> l) at_top"
 proof -
   define ff where "ff = (\<lambda>x. if x \<ge> b then f x else f b)"
   have m1:"mono (-ff)" unfolding ff_def mono_def using assms(1) by simp
   have m2:"\<And>x. (-ff) x \<le> -u" unfolding ff_def using assms(2) by simp
   from mono_inc_bdd_above_has_limit_at_topI[OF m1 m2]
   obtain l where "(-ff \<longlongrightarrow> l) at_top" by blast
   then have "(ff \<longlongrightarrow> -l) at_top"
     using tendsto_at_top_eq_left tendsto_minus_cancel_left by fastforce  
   thus ?thesis
     by (meson \<open>(ff \<longlongrightarrow> -l) at_top\<close> ff_def tendsto_at_top_eq_left)
 qed
 
 lemma infdist_closed:
   shows "closed ({z. infdist z S \<ge> e})"
   by (auto intro!:closed_Collect_le simp add:continuous_on_infdist)
 
 (* TODO: this is a copy of LIMSEQ_norm_0 where the sequence
   is bounded above in norm by a geometric series *)
 lemma LIMSEQ_norm_0_pow:
   assumes "k > 0" "b > 1"
   assumes  "\<And>n::nat. norm (s n) \<le> k / b^n"
   shows "s \<longlonglongrightarrow> 0"
 proof (rule metric_LIMSEQ_I)
   fix e
   assume "e > (0::real)"
   then have "k / e > 0" using assms(1) by auto
   obtain N where N: "b^(N::nat) > k / e" using assms(2)
-    using Elementary_Topology.real_arch_pow by blast
+    using real_arch_pow by blast
   then have "norm (s n) < e" if "n \<ge> N" for n
   proof -
     have "k / b^n \<le> k / b^N"
       by (smt assms(1) assms(2) frac_le leD power_less_imp_less_exp that zero_less_power)
     also have " ... < e" using N
       by (metis \<open>0 < e\<close> assms(2) less_trans mult.commute pos_divide_less_eq zero_less_one zero_less_power)
     finally show ?thesis
       by (meson assms less_eq_real_def not_le order_trans)
   qed
   then show "\<exists>no. \<forall>n\<ge>no. dist (s n) 0 < e"
     by auto
 qed
 
 lemma filterlim_apply_filtermap:
   assumes g: "filterlim g G F"
   shows "filterlim (\<lambda>x. m (g x)) (filtermap m G) F"
   by (metis filterlim_def filterlim_filtermap filtermap_mono g)
 
 lemma eventually_at_right_field_le:
   "eventually P (at_right x) \<longleftrightarrow> (\<exists>b>x. \<forall>y>x. y \<le> b \<longrightarrow> P y)"
   for x :: "'a::{linordered_field, linorder_topology}"
   by (smt dense eventually_at_right_field le_less_trans less_le_not_le order.strict_trans1)
 
 subsection \<open>indexing euclidean space with natural numbers\<close>
 
 definition  nth_eucl :: "'a::executable_euclidean_space \<Rightarrow> nat \<Rightarrow> real" where
   "nth_eucl x i = x \<bullet> (Basis_list ! i)"
   \<comment> \<open>TODO: why is that and some sort of \<open>lambda_eucl\<close> nowhere available?\<close>
 definition lambda_eucl :: "(nat \<Rightarrow> real) \<Rightarrow> 'a::executable_euclidean_space" where
   "lambda_eucl (f::nat\<Rightarrow>real) = (\<Sum>i<DIM('a). f i *\<^sub>R Basis_list ! i)"
 
 lemma eucl_eq_iff: "x = y \<longleftrightarrow> (\<forall>i<DIM('a). nth_eucl x i = nth_eucl y i)"
   for x y::"'a::executable_euclidean_space"
   apply (auto simp: nth_eucl_def euclidean_eq_iff[where 'a='a])
   by (metis eucl_of_list_list_of_eucl list_of_eucl_eq_iff)
 
 bundle eucl_notation begin
 notation nth_eucl (infixl "$\<^sub>e" 90)
 end
 bundle no_eucl_notation begin
 no_notation nth_eucl (infixl "$\<^sub>e" 90)
 end
 
 unbundle eucl_notation
 
 lemma eucl_of_list_eucl_nth:
   "(eucl_of_list xs::'a) $\<^sub>e i = xs ! i"
   if "length xs = DIM('a::executable_euclidean_space)"
     "i < DIM('a)"
   using that
   apply (auto simp: nth_eucl_def)
   by (metis list_of_eucl_eucl_of_list list_of_eucl_nth)
 
 lemma eucl_of_list_inner:
   "(eucl_of_list xs::'a) \<bullet> eucl_of_list ys = (\<Sum>(x,y)\<leftarrow>zip xs ys. x * y)"
   if "length xs = DIM('a::executable_euclidean_space)"
     "length ys = DIM('a::executable_euclidean_space)"
   using that
   by (auto simp: nth_eucl_def eucl_of_list_inner_eq inner_lv_rel_def)
 
 lemma self_eq_eucl_of_list: "x = eucl_of_list (map (\<lambda>i. x $\<^sub>e i) [0..<DIM('a)])"
   for x::"'a::executable_euclidean_space"
   by (auto simp: eucl_eq_iff[where 'a='a] eucl_of_list_eucl_nth)
 
 lemma inner_nth_eucl: "x \<bullet> y = (\<Sum>i<DIM('a). x $\<^sub>e i * y $\<^sub>e i)"
   for x y::"'a::executable_euclidean_space"
   apply (subst self_eq_eucl_of_list[where x=x])
   apply (subst self_eq_eucl_of_list[where x=y])
   apply (subst eucl_of_list_inner)
   by (auto simp: map2_map_map atLeast_upt interv_sum_list_conv_sum_set_nat)
 
 lemma norm_nth_eucl: "norm x = L2_set (\<lambda>i. x $\<^sub>e i) {..<DIM('a)}"
   for x::"'a::executable_euclidean_space"
   unfolding norm_eq_sqrt_inner inner_nth_eucl L2_set_def
   by (auto simp: power2_eq_square)
 
 
 lemma plus_nth_eucl: "(x + y) $\<^sub>e i = x $\<^sub>e i + y $\<^sub>e i"
   and minus_nth_eucl: "(x - y) $\<^sub>e i = x $\<^sub>e i - y $\<^sub>e i"
   and uminus_nth_eucl: "(-x) $\<^sub>e i = - x $\<^sub>e i"
   and scaleR_nth_eucl: "(c *\<^sub>R x) $\<^sub>e i = c *\<^sub>R (x $\<^sub>e i)"
   by (auto simp: nth_eucl_def algebra_simps)
 
 lemma inf_nth_eucl: "inf x y $\<^sub>e i = min (x $\<^sub>e i) (y $\<^sub>e i)"
   if "i < DIM('a)"
   for x::"'a::executable_euclidean_space"
   by (auto simp: nth_eucl_def algebra_simps inner_Basis_inf_left that inf_min)
 lemma sup_nth_eucl: "sup x y $\<^sub>e i = max (x $\<^sub>e i) (y $\<^sub>e i)"
   if "i < DIM('a)"
   for x::"'a::executable_euclidean_space"
   by (auto simp: nth_eucl_def algebra_simps inner_Basis_sup_left that sup_max)
 
 lemma le_iff_le_nth_eucl: "x \<le> y \<longleftrightarrow> (\<forall>i<DIM('a). (x $\<^sub>e i) \<le> (y $\<^sub>e i))"
   for x::"'a::executable_euclidean_space"
   apply (auto simp: nth_eucl_def algebra_simps eucl_le[where 'a='a])
   by (meson eucl_le eucl_le_Basis_list_iff)
 
 lemma eucl_less_iff_less_nth_eucl: "eucl_less x y \<longleftrightarrow> (\<forall>i<DIM('a). (x $\<^sub>e i) < (y $\<^sub>e i))"
   for x::"'a::executable_euclidean_space"
   apply (auto simp: nth_eucl_def algebra_simps eucl_less_def[where 'a='a])
   by (metis Basis_zero eucl_eq_iff inner_not_same_Basis inner_zero_left length_Basis_list
       nth_Basis_list_in_Basis nth_eucl_def)
 
 lemma continuous_on_nth_eucl[continuous_intros]:
   "continuous_on X (\<lambda>x. f x $\<^sub>e i)"
   if "continuous_on X f"
   by (auto simp: nth_eucl_def intro!: continuous_intros that)
 
 
 subsection \<open>derivatives\<close>
 
 lemma eventually_at_ne[intro, simp]: "\<forall>\<^sub>F x in at x0. x \<noteq> x0"
   by (auto simp: eventually_at_filter)
 
 lemma has_vector_derivative_withinD:
   fixes f::"real \<Rightarrow> 'b::euclidean_space"
   assumes "(f has_vector_derivative f') (at x0 within S)"
   shows "((\<lambda>x. (f x - f x0) /\<^sub>R (x - x0)) \<longlongrightarrow> f') (at x0 within S)"
   apply (rule LIM_zero_cancel)
   apply (rule tendsto_norm_zero_cancel)
   apply (rule Lim_transform_eventually)
 proof -
   show "\<forall>\<^sub>F x in at x0 within S. norm ((f x - f x0 - (x - x0) *\<^sub>R f') /\<^sub>R norm (x - x0)) =
     norm ((f x - f x0) /\<^sub>R (x - x0) - f')"
     (is "\<forall>\<^sub>F x in _. ?th x")
     unfolding eventually_at_filter
   proof (safe intro!: eventuallyI)
     fix x assume x: "x \<noteq> x0"
     then have "norm ((f x - f x0) /\<^sub>R (x - x0) - f') = norm (sgn (x - x0) *\<^sub>R ((f x - f x0) /\<^sub>R (x - x0) - f'))"
       by simp
     also have "sgn (x - x0) *\<^sub>R ((f x - f x0) /\<^sub>R (x - x0) - f') = ((f x - f x0) /\<^sub>R norm (x - x0) - (x - x0) *\<^sub>R f' /\<^sub>R norm (x - x0))"
       by (auto simp add: algebra_simps sgn_div_norm divide_simps)
         (metis add.commute add_divide_distrib diff_add_cancel scaleR_add_left)
     also have "\<dots> = (f x - f x0 - (x - x0) *\<^sub>R f') /\<^sub>R norm (x - x0)" by (simp add: algebra_simps)
     finally show "?th x" ..
   qed
   show "((\<lambda>x. norm ((f x - f x0 - (x - x0) *\<^sub>R f') /\<^sub>R norm (x - x0))) \<longlongrightarrow> 0) (at x0 within S)"
     by (rule tendsto_norm_zero)
       (use assms in \<open>auto simp: has_vector_derivative_def has_derivative_at_within\<close>)
 qed
 
 text \<open>A \<open>path_connected\<close> set \<open>S\<close> entering both \<open>T\<close> and \<open>-T\<close>
       must cross the frontier of \<open>T\<close> \<close>
 lemma path_connected_frontier:
   fixes S :: "'a::real_normed_vector set"
   assumes "path_connected S"
   assumes "S \<inter> T \<noteq> {}"
   assumes "S \<inter> -T \<noteq> {}"
   obtains s where "s \<in> S" "s \<in> frontier T"
 proof -
   obtain st where st:"st \<in> S \<inter> T" using assms(2) by blast
   obtain sn where sn:"sn \<in> S \<inter> -T" using assms(3) by blast
   obtain g where g: "path g" "path_image g \<subseteq> S"
     "pathstart g = st" "pathfinish g = sn"
     using assms(1) st sn unfolding path_connected_def by blast
   have a1:"pathstart g \<in> closure T" using st g(3) closure_Un_frontier by fastforce
   have a2:"pathfinish g \<notin> T" using sn g(4) by auto
   from exists_path_subpath_to_frontier[OF g(1) a1 a2]
   obtain h where "path_image h \<subseteq> path_image g" "pathfinish h \<in> frontier T" by metis
   thus ?thesis using g(2)
     by (meson in_mono pathfinish_in_path_image that) 
 qed
 
 lemma path_connected_not_frontier_subset:
   fixes S :: "'a::real_normed_vector set"
   assumes "path_connected S"
   assumes "S \<inter> T \<noteq> {}"
   assumes "S \<inter> frontier T = {}"
   shows "S \<subseteq> T"
   using path_connected_frontier assms by auto  
 
 lemma compact_attains_bounds:
   fixes f::"'a::topological_space \<Rightarrow> 'b::linorder_topology"
   assumes compact: "compact S"
   assumes ne: "S \<noteq> {}"
   assumes cont: "continuous_on S f"
   obtains l u where "l \<in> S" "u \<in> S" "\<And>x. x \<in> S \<Longrightarrow> f x \<in> {f l .. f u}"
 proof -
   from compact_continuous_image[OF cont compact]
   have compact_image: "compact (f ` S)" .
   have ne_image: "f ` S \<noteq> {}" using ne by simp
   from compact_attains_inf[OF compact_image ne_image]
   obtain l where "l \<in> S" "\<And>x. x \<in> S \<Longrightarrow> f l \<le> f x" by auto
   moreover
   from compact_attains_sup[OF compact_image ne_image]
   obtain u where "u \<in> S" "\<And>x. x \<in> S \<Longrightarrow> f x \<le> f u" by auto
   ultimately
   have "l \<in> S" "u \<in> S" "\<And>x. x \<in> S \<Longrightarrow> f x \<in> {f l .. f u}" by auto
   then show ?thesis ..
 qed
 
 lemma uniform_limit_const[uniform_limit_intros]:
   "uniform_limit S (\<lambda>x y. f x) (\<lambda>_. l) F" if "(f \<longlongrightarrow> l) F"
   apply (auto simp: uniform_limit_iff)
   subgoal for e
     using tendstoD[OF that(1), of e]
     by (auto simp: eventually_mono)
   done
 
 subsection \<open>Segments\<close>
 
 text \<open>\<open>closed_segment\<close> throws away the order that our intuition keeps\<close>
 
 definition line::"'a::real_vector \<Rightarrow> 'a \<Rightarrow> real \<Rightarrow> 'a"
   ("{_ -- _}\<^bsub>_\<^esub>")
   where "{a -- b}\<^bsub>u\<^esub> = a + u *\<^sub>R (b - a)"
 
 abbreviation "line_image a b U \<equiv>(\<lambda>u. {a -- b}\<^bsub>u\<^esub>) ` U"
 notation line_image ("{_ -- _}\<^bsub>`_\<^esub>")
 
 lemma in_closed_segment_iff_line: "x \<in> {a -- b} \<longleftrightarrow> (\<exists>c\<in>{0..1}. x = line a b c)"
   by (auto simp: in_segment line_def algebra_simps)
 
 lemma in_open_segment_iff_line: "x \<in> {a <--< b} \<longleftrightarrow> (\<exists>c\<in>{0<..<1}. a \<noteq> b \<and> x = line a b c)"
   by (auto simp: in_segment line_def algebra_simps)
 
 lemma line_convex_combination1: "(1 - u) *\<^sub>R line a b i + u *\<^sub>R b = line a b (i + u - i * u)"
   by (auto simp: line_def algebra_simps)
 
 lemma line_convex_combination2: "(1 - u) *\<^sub>R a + u *\<^sub>R line a b i = line a b (i*u)"
   by (auto simp: line_def algebra_simps)
 
 lemma line_convex_combination12: "(1 - u) *\<^sub>R line a b i + u *\<^sub>R line a b j = line a b (i + u * (j - i))"
   by (auto simp: line_def algebra_simps)
 
 lemma mult_less_one_less_self: "0 < x \<Longrightarrow> i < 1 \<Longrightarrow> i * x < x" for i x::real
   by auto
 
 lemma plus_times_le_one_lemma: "i + u - i * u \<le> 1" if "i \<le> 1" "u \<le> 1" for i u::real
   by (simp add: diff_le_eq sum_le_prod1 that)
 
 lemma plus_times_less_one_lemma: "i + u - i * u < 1" if "i < 1" "u < 1" for i u::real
 proof -
   have "u * (1 - i) < 1 - i"
     using that by force
   then show ?thesis by (simp add: algebra_simps)
 qed
 
 lemma line_eq_endpoint_iff[simp]:
   "line a b i = b \<longleftrightarrow> (a = b \<or> i = 1)"
   "a = line a b i \<longleftrightarrow> (a = b \<or> i = 0)"
   by (auto simp: line_def algebra_simps)
 
 lemma line_eq_iff[simp]: "line a b x = line a b y \<longleftrightarrow> (x = y \<or> a = b)"
   by (auto simp: line_def)
 
 lemma line_open_segment_iff:
   "{line a b i<--<b} = line a b ` {i<..<1}"
   if "i < 1" "a \<noteq> b"
   using that
   apply (auto simp: in_segment line_convex_combination1 plus_times_less_one_lemma)
   subgoal for j
     apply (rule exI[where x="(j - i)/(1 - i)"])
     apply (auto simp: divide_simps algebra_simps)
     by (metis add_diff_cancel less_numeral_extra(4) mult_2_right plus_times_less_one_lemma that(1))
   done
 
 lemma open_segment_line_iff:
   "{a<--<line a b i} = line a b ` {0<..<i}"
   if "0 < i" "a \<noteq> b"
   using that
   apply (auto simp: in_segment line_convex_combination2 plus_times_less_one_lemma)
   subgoal for j
     apply (rule exI[where x="j/i"])
     by (auto simp: )
   done
 
 lemma line_closed_segment_iff:
   "{line a b i--b} = line a b ` {i..1}"
   if "i \<le> 1" "a \<noteq> b"
   using that
   apply (auto simp: in_segment line_convex_combination1 mult_le_cancel_right2 plus_times_le_one_lemma)
   subgoal for j
     apply (rule exI[where x="(j - i)/(1 - i)"])
     apply (auto simp: divide_simps algebra_simps)
     by (metis add_diff_cancel less_numeral_extra(4) mult_2_right plus_times_less_one_lemma that(1))
   done
 
 lemma closed_segment_line_iff:
   "{a--line a b i} = line a b ` {0..i}"
   if "0 < i" "a \<noteq> b"
   using that
   apply (auto simp: in_segment line_convex_combination2 plus_times_less_one_lemma)
   subgoal for j
     apply (rule exI[where x="j/i"])
     by (auto simp: )
   done
 
 lemma closed_segment_line_line_iff: "{line a b i1--line a b i2} = line a b ` {i1..i2}" if "i1 \<le> i2"
   using that
   apply (auto simp: in_segment line_convex_combination12 intro!: imageI)
    apply (smt mult_left_le_one_le)
   subgoal for u
     by (rule exI[where x="(u - i1)/(i2-i1)"]) auto
   done
 
 lemma line_line1: "line (line a b c) b x = line a b (c + x - c * x)"
   by (simp add: line_def algebra_simps)
 
 lemma line_line2: "line a (line a b c) x = line a b (c*x)"
   by (simp add: line_def algebra_simps)
 
 lemma line_in_subsegment:
   "i1 < 1 \<Longrightarrow> i2 < 1 \<Longrightarrow> a \<noteq> b \<Longrightarrow> line a b i1 \<in> {line a b i2<--<b} \<longleftrightarrow> i2 < i1"
   by (auto simp: line_open_segment_iff intro!: imageI)
 
 lemma line_in_subsegment2:
   "0 < i2 \<Longrightarrow> 0 < i1 \<Longrightarrow> a \<noteq> b \<Longrightarrow> line a b i1 \<in> {a<--<line a b i2} \<longleftrightarrow> i1 < i2"
   by (auto simp: open_segment_line_iff intro!: imageI)
 
 lemma line_in_open_segment_iff[simp]:
   "line a b i \<in> {a<--<b} \<longleftrightarrow> (a \<noteq> b \<and> 0 < i \<and> i < 1)"
   by (auto simp: in_open_segment_iff_line)
 
 subsection \<open>Open Segments\<close>
 
 lemma open_segment_subsegment:
   assumes "x1 \<in> {x0<--<x3}"
     "x2 \<in> {x1<--<x3}"
   shows "x1 \<in> {x0<--<x2}"
   using assms
 proof -\<comment> \<open>TODO: use \<open>line\<close>\<close>
   from assms obtain u v::real where
     ne: "x0 \<noteq> x3" "(1 - u) *\<^sub>R x0 + u *\<^sub>R x3 \<noteq> x3"
     and x1_def: "x1 = (1 - u) *\<^sub>R x0 + u *\<^sub>R x3"
     and x2_def: "x2 = (1 - v) *\<^sub>R ((1 - u) *\<^sub>R x0 + u *\<^sub>R x3) + v *\<^sub>R x3"
     and uv: \<open>0 < u\<close> \<open>0 < v\<close> \<open>u < 1\<close> \<open>v < 1\<close>
     by (auto simp: in_segment)
   let ?d = "(u + v - u * v)"
   have "?d > 0" using uv
     by (auto simp: add_nonneg_pos pos_add_strict)
   with \<open>x0 \<noteq> x3\<close> have "0 \<noteq> ?d *\<^sub>R (x3 - x0)" by simp
   moreover
   define ua where "ua = u / ?d"
   have "ua * (u * v - u - v) - - u = 0"
     by (auto simp: ua_def algebra_simps divide_simps)
       (metis uv add_less_same_cancel1 add_strict_mono mult.right_neutral
         mult_less_cancel_left_pos not_real_square_gt_zero vector_space_over_itself.scale_zero_left)
   then have "(ua * (u * v - u - v) - - u) *\<^sub>R (x3 - x0) = 0"
     by simp
   moreover
   have "0 < ua" "ua < 1"
     using \<open>0 < u\<close> \<open>0 < v\<close> \<open>u < 1\<close> \<open>v < 1\<close>
     by (auto simp: ua_def pos_add_strict intro!: divide_pos_pos)
   ultimately show ?thesis
     unfolding x1_def x2_def
     by (auto intro!: exI[where x=ua] simp: algebra_simps in_segment)
 qed
 
 
 subsection \<open>Syntax\<close>
 
 abbreviation sequentially_at_top::"(nat\<Rightarrow>real)\<Rightarrow>bool"
   ("_ \<longlonglongrightarrow>\<^bsub>\<^esub> \<infinity>") \<comment> \<open>the \<open>\<^bsub>\<^esub>\<close> is to disambiguate syntax...\<close>
   where "s \<longlonglongrightarrow>\<^bsub>\<^esub> \<infinity>  \<equiv> filterlim s at_top sequentially"
 
 abbreviation sequentially_at_bot::"(nat\<Rightarrow>real)\<Rightarrow>bool"
   ("_ \<longlonglongrightarrow>\<^bsub>\<^esub> -\<infinity>")
   where "s \<longlonglongrightarrow>\<^bsub>\<^esub> -\<infinity>  \<equiv> filterlim s at_bot sequentially"
 
 
 subsection \<open>Paths\<close>
 
 lemma subpath0_linepath:
   shows "subpath 0 u (linepath t t') = linepath t (t + u * (t' - t))"
   unfolding subpath_def linepath_def
   apply (rule ext)
   apply auto
 proof -
   fix x :: real
   have f1: "\<And>r ra rb rc. (r::real) + ra * rb - ra * rc = r - ra * (rc - rb)"
     by (simp add: right_diff_distrib')
   have f2: "\<And>r ra. (r::real) - r * ra = r * (1 - ra)"
     by (simp add: right_diff_distrib')
   have f3: "\<And>r ra rb. (r::real) - ra + rb + ra - r = rb"
     by auto
   have f4: "\<And>r. (r::real) + (1 - 1) = r"
     by linarith
   have f5: "\<And>r ra. (r::real) + ra = ra + r"
     by force
   have f6: "\<And>r ra. (r::real) + (1 - (r + 1) + ra) = ra"
     by linarith
   have "t - x * (t - (t + u * (t' - t))) = t' * (u * x) + (t - t * (u * x))"
     by (simp add: right_diff_distrib')
   then show "(1 - u * x) * t + u * x * t' = (1 - x) * t + x * (t + u * (t' - t))"
     using f6 f5 f4 f3 f2 f1 by (metis (no_types) mult.commute)
 qed
 
 lemma linepath_image0_right_open_real:
   assumes "t < (t'::real)"
   shows "linepath t t' ` {0..<1} = {t..<t'}"
   unfolding linepath_def
   apply auto
     apply (metis add.commute add_diff_cancel_left' assms diff_diff_eq2 diff_le_eq less_eq_real_def mult.commute mult.right_neutral mult_right_mono right_diff_distrib')
    apply (smt assms comm_semiring_class.distrib mult_diff_mult semiring_normalization_rules(2) zero_le_mult_iff)
 proof -
   fix x
   assume "t \<le> x" "x < t'"
   let ?u = "(x-t)/(t'-t)"
   have "?u \<ge> 0"
     using \<open>t \<le> x\<close> assms by auto
   moreover have "?u < 1"
     by (simp add: \<open>x < t'\<close> assms)
   moreover have "x = (1-?u) * t + ?u*t'"
   proof -
     have f1: "\<forall>r ra. (ra::real) * - r = r * - ra"
       by simp
     have "t + (t' + - t) * ((x + - t) / (t' + - t)) = x"
       using assms by force
     then have "t' * ((x + - t) / (t' + - t)) + t * (1 + - ((x + - t) / (t' + - t))) = x"
       using f1 by (metis (no_types) add.left_commute distrib_left mult.commute mult.right_neutral)
     then show ?thesis
       by (simp add: mult.commute)
   qed
   ultimately show "x \<in> (\<lambda>x. (1 - x) * t + x * t') ` {0..<1}"
     using atLeastLessThan_iff by blast 
 qed
 
 lemma oriented_subsegment_scale:
   assumes "x1 \<in> {a<--<b}"
   assumes "x2 \<in> {x1<--<b}"
   obtains e where "e > 0" "b-a = e *\<^sub>R (x2-x1)"
 proof -
   from assms(1) obtain u where u : "u > 0" "u < 1" "x1 = (1 - u) *\<^sub>R a + u *\<^sub>R b"
     unfolding in_segment by blast
   from assms(2) obtain v where v: "v > 0" "v < 1" "x2 = (1 - v) *\<^sub>R x1 + v *\<^sub>R b"
     unfolding in_segment by blast
   have "x2-x1 = -v *\<^sub>R x1 + v *\<^sub>R b" using v
     by (metis add.commute add_diff_cancel_right diff_minus_eq_add scaleR_collapse scaleR_left.minus)
   also have "... = (-v) *\<^sub>R ((1 - u) *\<^sub>R a + u *\<^sub>R b)  + v *\<^sub>R b" using u by auto
   also have "... = v *\<^sub>R ((1-u)*\<^sub>R b - (1-u)*\<^sub>R a )"
     by (smt add_diff_cancel diff_diff_add diff_minus_eq_add minus_diff_eq scaleR_collapse scale_minus_left scale_right_diff_distrib)
   finally have x2x1:"x2-x1 = (v *(1-u)) *\<^sub>R (b - a)"
     by (metis scaleR_scaleR scale_right_diff_distrib)
   have "v * (1-u) > 0"  using u(2) v(1) by simp
   then have "(x2-x1)/\<^sub>R (v * (1-u)) = (b-a)" unfolding x2x1
     by (smt field_class.field_inverse scaleR_one scaleR_scaleR) 
   thus ?thesis
     using \<open>0 < v * (1 - u)\<close> positive_imp_inverse_positive that by fastforce
 qed
 
 end
diff --git a/thys/Poincare_Bendixson/Limit_Set.thy b/thys/Poincare_Bendixson/Limit_Set.thy
--- a/thys/Poincare_Bendixson/Limit_Set.thy
+++ b/thys/Poincare_Bendixson/Limit_Set.thy
@@ -1,473 +1,473 @@
 section \<open>Limit Sets\<close>
 theory Limit_Set
   imports Invariance
 begin
 
 context auto_ll_on_open begin
 text \<open>Positive limit point, assuming \<open>{0..} \<subseteq> existence_ivl0 x\<close>\<close>
 
 (* TODO: Perhaps a more intrinsic definition would be better here *)
 definition "\<omega>_limit_point x p \<longleftrightarrow>
   {0..} \<subseteq> existence_ivl0 x \<and>
   (\<exists>s. s \<longlonglongrightarrow>\<^bsub>\<^esub> \<infinity> \<and> (flow0 x \<circ> s) \<longlonglongrightarrow> p)"
 
 text \<open> Also called the \<open>\<omega>\<close>-limit set of x \<close>
 definition "\<omega>_limit_set x = {p. \<omega>_limit_point x p}"
 
 definition "\<alpha>_limit_point x p \<longleftrightarrow>
   {..0} \<subseteq> existence_ivl0 x \<and>
   (\<exists>s. s \<longlonglongrightarrow>\<^bsub>\<^esub> -\<infinity> \<and> (flow0 x \<circ> s) \<longlonglongrightarrow> p)"
 
 text \<open> Also called the \<open>\<alpha>\<close>-limit set of x \<close>
 definition "\<alpha>_limit_set x =
   {p. \<alpha>_limit_point x p}"
 
 end context auto_ll_on_open begin
 
 lemma \<alpha>_limit_point_eq_rev: "\<alpha>_limit_point x p = rev.\<omega>_limit_point x p"
   unfolding \<alpha>_limit_point_def rev.\<omega>_limit_point_def
   apply (auto simp: rev_eq_flow[abs_def] o_def filterlim_uminus_at_bot rev_existence_ivl_eq0 subset_iff
       intro: exI[where x="uminus o s" for s])
   using neg_0_le_iff_le by fastforce
 
 lemma \<alpha>_limit_set_eq_rev: "\<alpha>_limit_set x = rev.\<omega>_limit_set x"
   unfolding \<alpha>_limit_set_def rev.\<omega>_limit_set_def \<alpha>_limit_point_eq_rev ..
 
 lemma \<omega>_limit_pointE:
   assumes "\<omega>_limit_point x p"
   obtains s where
     "filterlim s at_top sequentially"
     "(flow0 x \<circ> s) \<longlonglongrightarrow> p"
     "\<forall>n. b \<le> s n"
   using assms filterlim_at_top_choose_lower \<omega>_limit_point_def by blast
 
 lemma \<omega>_limit_set_eq:
   assumes "{0..} \<subseteq> existence_ivl0 x"
   shows "\<omega>_limit_set x = (INF \<tau> \<in> {0..}. closure (flow0 x ` {\<tau>..}))"
   unfolding \<omega>_limit_set_def
 proof safe
   fix p t
   assume pt: "0 \<le> (t::real)" "\<omega>_limit_point x p"
   from \<omega>_limit_pointE[OF pt(2)]
   obtain s where
     "filterlim s at_top sequentially"
     "(flow0 x \<circ> s) \<longlonglongrightarrow> p"
     "\<forall>n. t \<le> s n" by blast
   thus "p \<in> closure (flow0 x ` {t..})" unfolding closure_sequential
     by (metis atLeast_iff comp_apply imageI)
 next
   fix p
   assume "p \<in> (\<Inter>\<tau>\<in>{0..}. closure (flow0 x ` {\<tau>..}))"
   then have "\<And>t. t \<ge>0 \<Longrightarrow> p \<in> closure (flow0 x ` {t..})" by blast
   then have "\<And>t e. t \<ge>0 \<Longrightarrow> e > 0 \<Longrightarrow> (\<exists>tt \<ge> t. dist (flow0 x tt) p < e)"
     unfolding closure_approachable
     by fastforce
   from approachable_sequenceE[OF this]
   obtain s where "filterlim s at_top sequentially" "(flow0 x \<circ> s) \<longlonglongrightarrow> p" by auto
   thus "\<omega>_limit_point x p" unfolding \<omega>_limit_point_def using assms by auto
 qed
 
 lemma \<omega>_limit_set_empty:
   assumes "\<not> ({0..} \<subseteq> existence_ivl0 x)"
   shows "\<omega>_limit_set x = {}"
   unfolding \<omega>_limit_set_def \<omega>_limit_point_def
   by (simp add: assms)
 
 lemma \<omega>_limit_set_closed: "closed (\<omega>_limit_set x)"
   using \<omega>_limit_set_eq
   by (metis \<omega>_limit_set_empty closed_INT closed_closure closed_empty)
 
 (* TODO: Walter gives a more direct proof *)
 lemma \<omega>_limit_set_positively_invariant:
   shows "positively_invariant (\<omega>_limit_set x)"
   unfolding positively_invariant_def trapped_forward_def
 proof safe
   fix dummy p t
   assume xa: "p \<in> \<omega>_limit_set x"
     "t \<in> existence_ivl0 p"
     "0 \<le> t"
   have "p \<in> X" using mem_existence_ivl_iv_defined(2) xa(2) by blast
   have exist: "{0..} \<subseteq> existence_ivl0 x" using xa(1)
     unfolding \<omega>_limit_set_def \<omega>_limit_point_def by auto
   from xa(1)
   obtain s where s:
     "filterlim s at_top sequentially"
     "(flow0 x \<circ> s) \<longlonglongrightarrow> p"
     "\<forall>n. 0 \<le> s n"
     unfolding \<omega>_limit_set_def by (auto elim!:\<omega>_limit_pointE)
   define r where "r = (\<lambda>n. t + s n)"
   have rlim: "filterlim r at_top sequentially" unfolding r_def
     by (auto intro: filterlim_tendsto_add_at_top[OF _ s(1)])
   define dom where "dom = image (flow0 x) {0..} \<union> {p} "
   have domin: "\<forall>n. (flow0 x \<circ> s) n \<in> dom" "p \<in> dom" unfolding dom_def o_def
     using exist by(auto simp add: s(3))
   have xt: "\<And>x. x \<in> dom \<Longrightarrow> t \<in> existence_ivl0 x" unfolding dom_def using xa(2)
     apply auto
     apply (rule existence_ivl_trans')
     using exist xa(3) apply auto[1]
     using exist  by auto
   have cont: "continuous_on dom (\<lambda>x. flow0 x t)"
     apply (rule flow_continuous_on_compose)
        apply auto
     using \<open>p \<in> X\<close>  exist local.dom_def local.flow_in_domain apply auto[1]
     using xt .
   then have f1: "((\<lambda>x. flow0 x t) \<circ> (flow0 x \<circ> s)) \<longlonglongrightarrow> flow0 p t" using domin s(2)
     unfolding continuous_on_sequentially
     by blast
   have ff:"\<And>n. (flow0 x \<circ> r) n = ((\<lambda>x. flow0 x t) \<circ> (flow0 x \<circ> s)) n"
     unfolding o_def r_def
   proof -
     fix n
     have s:"s n \<in> existence_ivl0 x"
       using s(3) exist by auto
     then have t:"t \<in> existence_ivl0 (flow0 x (s n))"
       using domin(1) xt by auto
     from flow_trans[OF s t]
     show "flow0 x (t + s n) = flow0 (flow0 x (s n)) t"
       by (simp add: add.commute)
   qed
   have f2: "(flow0 x \<circ> r) \<longlonglongrightarrow> flow0 p t" using f1 unfolding ff .
   show "flow0 p t \<in> \<omega>_limit_set x" using exist f2 rlim
     unfolding \<omega>_limit_set_def \<omega>_limit_point_def
     using flow_in_domain r_def s(3) xa(2) xa(3) by auto
 qed
 
 lemma \<omega>_limit_set_invariant:
   shows "invariant (\<omega>_limit_set x)"
   unfolding invariant_iff_pos_invariant_and_compl_pos_invariant
 proof safe
   show "positively_invariant (\<omega>_limit_set x)"
     using \<omega>_limit_set_positively_invariant .
 next
   show "positively_invariant (X - \<omega>_limit_set x)"
     unfolding positively_invariant_def trapped_forward_def
     apply safe
     using local.flow_in_domain apply blast
   proof -
     fix dummy p t 
     assume xa: "p \<in> X" "p \<notin> \<omega>_limit_set x"
       "t \<in> existence_ivl0 p" "0 \<le> t"
       and f: "flow0 p t \<in> \<omega>_limit_set x"
     have exist: "{0..} \<subseteq> existence_ivl0 x" using f
       unfolding \<omega>_limit_set_def \<omega>_limit_point_def by auto
     from f
     obtain s where s:
       "filterlim s at_top sequentially"
       "(flow0 x \<circ> s) \<longlonglongrightarrow> flow0 p t"
       "\<forall>n. t \<le> s n"
       unfolding \<omega>_limit_set_def by (auto elim!:\<omega>_limit_pointE)
     define r where "r = (\<lambda>n. (-t) + s n)"
     have "(\<lambda>x. -t) \<longlonglongrightarrow> -t" by simp
     from filterlim_tendsto_add_at_top[OF this s(1)]
     have rlim: "filterlim r at_top sequentially" unfolding r_def by simp
     define dom where "dom = image (flow0 x) {t..} \<union> {flow0 p t} "
     have domin: "\<forall>n. (flow0 x \<circ> s) n \<in> dom" "flow0 p t \<in> dom" unfolding dom_def o_def
       using exist by(auto simp add: s(3))
     have xt: "\<And>x. x \<in> dom \<Longrightarrow> -t \<in> existence_ivl0 x" unfolding dom_def using xa(2)
       apply auto
       using local.existence_ivl_reverse xa(3) apply auto[1]
       by (metis exist atLeast_iff diff_conv_add_uminus diff_ge_0_iff_ge linordered_ab_group_add_class.zero_le_double_add_iff_zero_le_single_add local.existence_ivl_trans' order_trans subset_iff xa(4))
     have cont: "continuous_on dom (\<lambda>x. flow0 x (-t))"
       apply (rule flow_continuous_on_compose)
          apply auto
       using local.mem_existence_ivl_iv_defined(2) xt apply blast
       by (simp add: xt)
     then have f1: "((\<lambda>x. flow0 x (-t)) \<circ> (flow0 x \<circ> s)) \<longlonglongrightarrow> flow0 (flow0 p t) (-t)" using domin s(2)
       unfolding continuous_on_sequentially
       by blast
     have ff:"\<And>n. (flow0 x \<circ> r) n = ((\<lambda>x. flow0 x (-t)) \<circ> (flow0 x \<circ> s)) n"
       unfolding o_def r_def
     proof -
       fix n
       have s:"s n \<in> existence_ivl0 x"
         using s(3) exist \<open>0\<le> t\<close> by (meson atLeast_iff order_trans subset_eq)
       then have t:"-t \<in> existence_ivl0 (flow0 x (s n))"
         using domin(1) xt by auto
       from flow_trans[OF s t]
       show "flow0 x (-t + s n) = flow0 (flow0 x (s n)) (-t)"
         by (simp add: add.commute)
     qed
     have "(flow0 x \<circ> r) \<longlonglongrightarrow> flow0 (flow0 p t) (-t)" using f1 unfolding ff .
     then have f2: "(flow0 x \<circ> r) \<longlonglongrightarrow> p" using flows_reverse xa(3) by auto
     then have "p \<in> \<omega>_limit_set x" unfolding \<omega>_limit_set_def \<omega>_limit_point_def
       using rlim exist by auto
     thus False using xa(2) by auto
   qed
 qed
 
 end context auto_ll_on_open begin
 
 lemma \<alpha>_limit_set_eq:
   assumes "{..0} \<subseteq> existence_ivl0 x"
   shows "\<alpha>_limit_set x = (INF \<tau> \<in> {..0}. closure (flow0 x ` {..\<tau>}))"
   using rev.\<omega>_limit_set_eq[of x, OF assms[folded infinite_rev_existence_ivl0_rewrites]]
   unfolding \<alpha>_limit_set_eq_rev rev_flow_image_eq image_uminus_atLeast 
   by (smt INT_extend_simps(10) Sup.SUP_cong image_uminus_atMost)
 
 lemma \<alpha>_limit_set_closed:
   shows "closed (\<alpha>_limit_set x)"
   unfolding \<alpha>_limit_set_eq_rev by (rule rev.\<omega>_limit_set_closed)
 
 lemma \<alpha>_limit_set_positively_invariant:
   shows "negatively_invariant (\<alpha>_limit_set x)"
   unfolding negatively_invariant_eq_rev \<alpha>_limit_set_eq_rev
   by (simp add: rev.\<omega>_limit_set_positively_invariant)
 
 lemma \<alpha>_limit_set_invariant:
   shows "invariant (\<alpha>_limit_set x)"
   unfolding invariant_eq_rev \<alpha>_limit_set_eq_rev
   by (simp add: rev.\<omega>_limit_set_invariant)
 
 text \<open> Fundamental properties of the positive limit set \<close>
 
 context
   fixes x K
   assumes K: "compact K" "K \<subseteq> X"
   assumes x: "x \<in> X" "trapped_forward x K"
 begin
 
 text \<open>Bunch of facts for what's to come\<close>
 private lemma props:
   shows "{0..} \<subseteq> existence_ivl0 x" "seq_compact K"
    apply (rule trapped_sol_right)
   using x K by (auto simp add: compact_imp_seq_compact)
 
 private lemma flowimg:
   shows "flow0 x ` (existence_ivl0 x \<inter> {0..}) = flow0 x ` {0..}"
   using props(1) by auto
 
 lemma \<omega>_limit_set_in_compact_subset:
   shows "\<omega>_limit_set x \<subseteq> K"
   unfolding \<omega>_limit_set_def
 proof safe
   fix p s
   assume "\<omega>_limit_point x p"
   from \<omega>_limit_pointE[OF this]
   obtain s where s:
     "filterlim s at_top sequentially"
     "(flow0 x \<circ> s) \<longlonglongrightarrow> p"
     "\<forall>n. 0 \<le> s n" by blast
   then have fin: "\<forall>n. (flow0 x \<circ> s) n \<in> K" using s(3) x K props(1)
     unfolding trapped_forward_def
     by (simp add: subset_eq)
   from seq_compactE[OF props(2) fin]
   show "p \<in> K" using s(2)
     by (metis LIMSEQ_subseq_LIMSEQ LIMSEQ_unique)
 qed
 
 lemma \<omega>_limit_set_in_compact_compact:
   shows "compact (\<omega>_limit_set x)"
 proof -
   from \<omega>_limit_set_in_compact_subset 
   have "bounded (\<omega>_limit_set x)"
     using bounded_subset compact_imp_bounded
     using K(1) by auto
   thus ?thesis using \<omega>_limit_set_closed
     by (simp add: compact_eq_bounded_closed)
 qed
 
 lemma \<omega>_limit_set_in_compact_nonempty:
   shows "\<omega>_limit_set x \<noteq> {}"
 proof -
   have fin: "\<forall>n. (flow0 x \<circ> real) n \<in> K" using x K props(1)
     by (simp add: flowimg image_subset_iff trapped_forward_def)
   from seq_compactE[OF props(2) this]
   obtain r l where "l \<in> K" "strict_mono r" "(flow0 x \<circ> real \<circ> r) \<longlonglongrightarrow> l" by blast
   then have "\<omega>_limit_point x l" unfolding \<omega>_limit_point_def using props(1)
     by (smt comp_def filterlim_sequentially_iff_filterlim_real filterlim_subseq tendsto_at_top_eq_left)
   thus ?thesis unfolding \<omega>_limit_set_def by auto
 qed
 
 lemma \<omega>_limit_set_in_compact_existence:
   shows "\<And>y. y \<in> \<omega>_limit_set x \<Longrightarrow> existence_ivl0 y = UNIV"
 proof -
   fix y
   assume y: "y \<in> \<omega>_limit_set x"
   then have "y \<in> X" using \<omega>_limit_set_in_compact_subset K by blast 
   from \<omega>_limit_set_invariant
   have "\<And>t. t \<in> existence_ivl0 y \<Longrightarrow> flow0 y t \<in> \<omega>_limit_set x"
     unfolding invariant_def trapped_iff_on_existence_ivl0 using y by blast 
   then have t: "\<And>t. t \<in> existence_ivl0 y \<Longrightarrow> flow0 y t \<in> K"
     using \<omega>_limit_set_in_compact_subset by blast
   thus "existence_ivl0 y = UNIV" 
     by (meson \<open>y \<in> X\<close> existence_ivl_zero existence_ivl_initial_time_iff existence_ivl_subset mem_compact_implies_subset_existence_interval subset_antisym K)
 qed
 
 lemma \<omega>_limit_set_in_compact_tendsto:
   shows "((\<lambda>t. infdist (flow0 x t) (\<omega>_limit_set x)) \<longlongrightarrow> 0) at_top"
 proof (rule ccontr)
   assume "\<not> ((\<lambda>t. infdist (flow0 x t) (\<omega>_limit_set x)) \<longlongrightarrow> 0) at_top"
   from not_tendsto_frequentlyE[OF this]
   obtain S where S: "open S" "0 \<in> S"
     "\<exists>\<^sub>F t in at_top. infdist (flow0 x t) (\<omega>_limit_set x) \<notin> S" .
   then obtain e where "e > 0" "ball 0 e \<subseteq> S" using openE by blast
   then have "\<And>x. x \<ge>0 \<Longrightarrow> x \<notin> S \<Longrightarrow> x \<ge> e" by force
   then have "\<forall>xa. infdist (flow0 x xa) (\<omega>_limit_set x) \<notin> S \<longrightarrow>
         infdist (flow0 x xa) (\<omega>_limit_set x) \<ge> e" using infdist_nonneg by blast  
   from frequently_mono[OF this S(3)]
   have "\<exists>\<^sub>F t in at_top. infdist (flow0 x t) (\<omega>_limit_set x) \<ge> e" by blast
   then have "\<forall>n. \<exists>\<^sub>F t in at_top. infdist (flow0 x t) (\<omega>_limit_set x) \<ge> e \<and> real n \<le> t"
     by (auto intro!: eventually_frequently_conj)
   from frequently_at_topE[OF this]
   obtain s where s: "\<And>i. e \<le> infdist (flow0 x (s i)) (\<omega>_limit_set x)"
     "\<And>i. real i \<le> s i" "strict_mono s" by force
   then have sf: "filterlim s at_top sequentially"
     using filterlim_at_top_mono filterlim_real_sequentially not_eventuallyD by blast 
   have fin: "\<forall>n. (flow0 x \<circ> s) n \<in> K"  using x K props(1) s unfolding flowimg trapped_forward_def
     by (metis atLeast_iff comp_apply image_subset_iff of_nat_0_le_iff order_trans)
   from seq_compactE[OF props(2) this]
   obtain r l where r:"strict_mono r" and l: "l \<in> K" "(flow0 x \<circ> s \<circ> r) \<longlonglongrightarrow> l" by blast
   moreover from filterlim_at_top_strict_mono[OF s(3) r(1) sf]
   have "filterlim (s \<circ> r) at_top sequentially" .
   moreover have "\<omega>_limit_point x l" unfolding \<omega>_limit_point_def using props(1) calculation
     by (metis comp_assoc)
   ultimately have "infdist l (\<omega>_limit_set x) = 0" by (simp add: \<omega>_limit_set_def)
   then have c1:"((\<lambda>y. infdist y (\<omega>_limit_set x)) \<circ> (flow0 x \<circ> s \<circ> r)) \<longlonglongrightarrow> 0"
-    using l(2) continuous_on_infdist
-    by (metis UNIV_I continuous_on_sequentially)
+    by (auto intro!: tendsto_compose_at[OF l(2)] tendsto_eq_intros)
   have c2: "\<And>i. e \<le> infdist (flow0 x ((s \<circ> r) i)) (\<omega>_limit_set x)" using s(1) by simp
   show False using c1 c2 \<open>e > 0\<close> unfolding o_def
-    using Lim_bounded2 s(1) by fastforce
+    using Lim_bounded2
+    by (metis (no_types, lifting) ball_eq_empty centre_in_ball empty_iff)
 qed
 
 lemma \<omega>_limit_set_in_compact_connected:
   shows "connected (\<omega>_limit_set x)"
   unfolding connected_closed_set[OF \<omega>_limit_set_closed]
 proof clarsimp
   fix Apre Bpre
   assume pre: "closed Apre" "Apre \<union> Bpre = \<omega>_limit_set x" "closed Bpre"
     "Apre \<noteq> {}" "Bpre \<noteq> {}" "Apre \<inter> Bpre = {}"
     (* TODO: this move is very strange *)
   then obtain A B where "Apre \<subseteq> A" "Bpre \<subseteq> B" "open A" "open B" and disj:"A \<inter> B = {}"
     by (meson t4_space)
   then have "\<omega>_limit_set x \<subseteq> A \<union> B"
     "\<omega>_limit_set x \<inter> A \<noteq> {}" "\<omega>_limit_set x \<inter> B \<noteq> {}" using pre by auto
   then obtain p q where
     p: "\<omega>_limit_point x p" "p \<in> A"
     and q: "\<omega>_limit_point x q" "q \<in> B"
     using \<omega>_limit_set_def by auto
   from \<omega>_limit_pointE[OF p(1)]
   obtain ps where ps: "filterlim ps at_top sequentially"
     "(flow0 x \<circ> ps) \<longlonglongrightarrow> p" "\<forall>n. 0 \<le> ps n" by blast
   from \<omega>_limit_pointE[OF q(1)]
   obtain qs where qs: "filterlim qs at_top sequentially"
     "(flow0 x \<circ> qs) \<longlonglongrightarrow> q" "\<forall>n. 0 \<le> qs n" by blast
   have "\<forall>n. \<exists>\<^sub>F t in at_top. flow0 x t \<notin> A \<and> flow0 x t \<notin> B" unfolding frequently_at_top
   proof safe
     fix dummy mpre
     obtain m where "m \<ge> (0::real)" "m > mpre"
       by (meson approximation_preproc_push_neg(1) gt_ex le_cases order_trans) 
     from ps obtain a where a:"a > m" "(flow0 x a) \<in> A"
-      using \<open>open A\<close> p unfolding tendsto_explicit filterlim_at_top eventually_sequentially
+      using \<open>open A\<close> p unfolding tendsto_def filterlim_at_top eventually_sequentially
       by (metis approximation_preproc_push_neg(1) comp_apply gt_ex le_cases order_trans)
     from qs obtain b where b:"b > a" "(flow0 x b) \<in> B"
-      using \<open>open B\<close> q unfolding tendsto_explicit filterlim_at_top eventually_sequentially
+      using \<open>open B\<close> q unfolding tendsto_def filterlim_at_top eventually_sequentially
       by (metis approximation_preproc_push_neg(1) comp_apply gt_ex le_cases order_trans)
     have "continuous_on {a..b} (flow0 x)"
       by (metis Icc_subset_Ici_iff \<open>0 \<le> m\<close> \<open>m < a\<close> approximation_preproc_push_neg(2) atMost_iff atMost_subset_iff continuous_on_subset le_cases local.flow_continuous_on props(1) subset_eq)
     from connected_continuous_image[OF this connected_Icc]
     have c:"connected (flow0 x ` {a..b})" .
     have "\<exists>t\<in> {a..b}. flow0 x t \<notin> A \<and> flow0 x t \<notin> B"
     proof (rule ccontr)
       assume "\<not> (\<exists>t\<in>{a..b}. flow0 x t \<notin> A \<and> flow0 x t \<notin> B)"
       then have "flow0 x ` {a..b} \<subseteq> A \<union> B" by blast
-      from connectedD[OF c \<open>open A\<close> \<open>open B\<close> this]
+      from topological_space_class.connectedD[OF c \<open>open A\<close> \<open>open B\<close> _ this]
       show False using a b disj by force
     qed
     thus "\<exists>n>mpre. flow0 x n \<notin> A \<and> flow0 x n \<notin> B"
-      by (smt \<open>mpre < m\<close> a(1) atLeastAtMost_iff) 
+      by (smt \<open>mpre < m\<close> a(1) atLeastAtMost_iff)
   qed
   from frequently_at_topE'[OF this filterlim_real_sequentially]
   obtain s where s: "\<forall>i. flow0 x (s i) \<notin> A \<and> flow0 x (s i) \<notin> B"
     "strict_mono s" "\<And>n. real n \<le> s n" by blast
   then have "\<forall>n. (flow0 x \<circ> s) n \<in> K"
     by (smt atLeast_iff comp_apply flowimg image_subset_iff of_nat_0_le_iff trapped_forward_def x(2))
   from seq_compactE[OF props(2) this]
   obtain r l where r: "l \<in> K" "strict_mono r" "(flow0 x \<circ> s \<circ> r) \<longlonglongrightarrow> l" by blast
   have "filterlim s at_top sequentially"
     using s filterlim_at_top_mono filterlim_real_sequentially not_eventuallyD by blast 
   from filterlim_at_top_strict_mono[OF s(2) r(2) this]
   have "filterlim (s \<circ> r) at_top sequentially" .
   then have "\<omega>_limit_point x l" unfolding \<omega>_limit_point_def using props(1) r
     by (metis comp_assoc)
-  moreover have "l \<notin> A" using s(1) r(3) \<open>open A\<close> unfolding tendsto_explicit by auto
-  moreover have "l \<notin> B" using s(1) r(3) \<open>open B\<close> unfolding tendsto_explicit by auto
+  moreover have "l \<notin> A" using s(1) r(3) \<open>open A\<close> unfolding tendsto_def by auto
+  moreover have "l \<notin> B" using s(1) r(3) \<open>open B\<close> unfolding tendsto_def by auto
   ultimately show False using \<open>\<omega>_limit_set x \<subseteq> A \<union> B\<close> unfolding \<omega>_limit_set_def
     by auto
 qed
 
 lemma \<omega>_limit_set_in_compact_\<omega>_limit_set_contained:
   shows "\<forall>y \<in> \<omega>_limit_set x. \<omega>_limit_set y \<subseteq> \<omega>_limit_set x"
 proof safe
   fix y z
   assume "y \<in> \<omega>_limit_set x" "z \<in> \<omega>_limit_set y"
   then have "\<omega>_limit_point y z" unfolding \<omega>_limit_set_def by auto
   from \<omega>_limit_pointE[OF this]
   obtain s where s: "(flow0 y \<circ> s) \<longlonglongrightarrow> z" .
   have "\<forall>n. (flow0 y \<circ> s) n \<in> \<omega>_limit_set x"
     using \<open>y \<in> \<omega>_limit_set x\<close> invariant_def
       \<omega>_limit_set_in_compact_existence \<omega>_limit_set_invariant trapped_iff_on_existence_ivl0
     by force
   thus "z \<in> \<omega>_limit_set x" using closed_sequential_limits s \<omega>_limit_set_closed
     by blast
 qed
 
 lemma \<omega>_limit_set_in_compact_\<alpha>_limit_set_contained:
   assumes zpx: "z \<in> \<omega>_limit_set x"
   shows "\<alpha>_limit_set z \<subseteq> \<omega>_limit_set x"
 proof
   fix w assume "w \<in> \<alpha>_limit_set z"
   then obtain s where s: "(flow0 z \<circ> s) \<longlonglongrightarrow> w"
     unfolding \<alpha>_limit_set_def \<alpha>_limit_point_def
     by auto
   from \<omega>_limit_set_invariant have "invariant (\<omega>_limit_set x)" .
   then have "\<forall>n. (flow0 z \<circ> s) n \<in> \<omega>_limit_set x"
     using \<omega>_limit_set_in_compact_existence[OF zpx] zpx
     using invariant_def trapped_iff_on_existence_ivl0 by fastforce
   from closed_sequentially[OF \<omega>_limit_set_closed this s]
   show "w \<in> \<omega>_limit_set x" .
 qed
 
 end
 
 text \<open> Fundamental properties of the negative limit set \<close>
 
 end context auto_ll_on_open begin
 
 context
   fixes x K
   assumes x: "x \<in> X" "trapped_backward x K"
   assumes K: "compact K" "K \<subseteq> X"
 begin
 
 private lemma xrev: "x \<in> X" "rev.trapped_forward x K"
   using trapped_backward_iff_rev_trapped_forward x(2) 
   by (auto simp: rev_existence_ivl_eq0 rev_eq_flow x(1))
 
 lemma \<alpha>_limit_set_in_compact_subset: "\<alpha>_limit_set x \<subseteq> K"
   and \<alpha>_limit_set_in_compact_compact: "compact (\<alpha>_limit_set x)"
   and \<alpha>_limit_set_in_compact_nonempty: "\<alpha>_limit_set x \<noteq> {}"
   and \<alpha>_limit_set_in_compact_connected: "connected (\<alpha>_limit_set x)"
   and \<alpha>_limit_set_in_compact_\<alpha>_limit_set_contained:
   "\<forall>y \<in> \<alpha>_limit_set x. \<alpha>_limit_set y \<subseteq> \<alpha>_limit_set x"
   and \<alpha>_limit_set_in_compact_tendsto: "((\<lambda>t. infdist (flow0 x t) (\<alpha>_limit_set x)) \<longlongrightarrow> 0) at_bot"
   using rev.\<omega>_limit_set_in_compact_subset[OF K xrev]
   using rev.\<omega>_limit_set_in_compact_compact[OF K xrev]
   using rev.\<omega>_limit_set_in_compact_nonempty[OF K xrev]
   using rev.\<omega>_limit_set_in_compact_connected[OF K xrev]
   using rev.\<omega>_limit_set_in_compact_\<omega>_limit_set_contained[OF K xrev]
   using rev.\<omega>_limit_set_in_compact_tendsto[OF K xrev]
   unfolding invariant_eq_rev \<alpha>_limit_set_eq_rev existence_ivl_eq_rev flow_eq_rev0 filterlim_at_bot_mirror
     minus_minus
   .
 
 lemma \<alpha>_limit_set_in_compact_existence:
   shows "\<And>y. y \<in> \<alpha>_limit_set x \<Longrightarrow> existence_ivl0 y = UNIV"
   using rev.\<omega>_limit_set_in_compact_existence[OF K xrev]
   unfolding \<alpha>_limit_set_eq_rev existence_ivl_eq_rev0
   by auto
 
 end
 end
 
 end
diff --git a/thys/Poincare_Bendixson/ODE_Misc.thy b/thys/Poincare_Bendixson/ODE_Misc.thy
--- a/thys/Poincare_Bendixson/ODE_Misc.thy
+++ b/thys/Poincare_Bendixson/ODE_Misc.thy
@@ -1,1111 +1,1111 @@
 section \<open>Additions to the ODE Library\<close>
 theory ODE_Misc
   imports
     Ordinary_Differential_Equations.ODE_Analysis
     Analysis_Misc
 begin
 
 lemma local_lipschitz_compact_bicomposeE:
   assumes ll: "local_lipschitz T X f"
   assumes cf: "\<And>x. x \<in> X \<Longrightarrow> continuous_on I (\<lambda>t. f t x)"
   assumes cI: "compact I"
   assumes "I \<subseteq> T"
   assumes cv: "continuous_on I v"
   assumes cw: "continuous_on I w"
   assumes v: "v ` I \<subseteq> X"
   assumes w: "w ` I \<subseteq> X"
   obtains L where "L > 0" "\<And>x. x \<in> I \<Longrightarrow> dist (f x (v x)) (f x (w x)) \<le> L * dist (v x) (w x)"
 proof -
   from v w have "v ` I \<union> w ` I \<subseteq> X" by auto
   with ll \<open>I \<subseteq> T\<close> have llI:"local_lipschitz I (v ` I \<union> w ` I) f"
     by (rule local_lipschitz_subset)
   have cvwI: "compact (v ` I \<union> w ` I)"
     by (auto intro!: compact_continuous_image cv cw cI)    
 
   from local_lipschitz_compact_implies_lipschitz[OF llI cvwI \<open>compact I\<close> cf]
   obtain L where L: "\<And>t. t \<in> I \<Longrightarrow> L-lipschitz_on (v ` I \<union> w ` I) (f t)"
     using v w
     by blast
   define L' where "L' = max L 1"
   with L have "L' > 0" "\<And>x. x \<in> I \<Longrightarrow> dist (f x (v x)) (f x (w x)) \<le> L' * dist (v x) (w x)"
      apply (auto simp: lipschitz_on_def L'_def)
     by (smt Un_iff image_eqI mult_right_mono zero_le_dist)
   then show ?thesis ..
 qed
 
 subsection \<open>Comparison Principle\<close>
 
 lemma comparison_principle_le:
   fixes f::"real \<Rightarrow> real \<Rightarrow> real"
     and \<phi> \<psi>::"real \<Rightarrow> real"
   assumes ll: "local_lipschitz X Y f"
   assumes cf: "\<And>x. x \<in> Y \<Longrightarrow> continuous_on {a..b} (\<lambda>t. f t x)"
   assumes abX: "{a .. b} \<subseteq> X"
   assumes \<phi>': "\<And>x. x \<in> {a .. b} \<Longrightarrow> (\<phi> has_real_derivative \<phi>' x) (at x)"
   assumes \<psi>': "\<And>x. x \<in> {a .. b} \<Longrightarrow> (\<psi> has_real_derivative \<psi>' x) (at x)"
   assumes \<phi>_in: "\<phi> ` {a..b} \<subseteq> Y"
   assumes \<psi>_in: "\<psi> ` {a..b} \<subseteq> Y"
   assumes init: "\<phi> a \<le> \<psi> a"
   assumes defect: "\<And>x. x \<in> {a .. b} \<Longrightarrow> \<phi>' x - f x (\<phi> x) \<le> \<psi>' x - f x (\<psi> x)"
   shows "\<forall>x \<in> {a .. b}. \<phi> x \<le> \<psi> x" (is "?th1")
     (*
     "(\<forall>x \<in> {a .. b}. \<phi> x < \<psi> x) \<or> (\<exists>c\<in>{a..b}. (\<forall>x\<in>{a..c}. \<phi> x \<le> \<psi> x) \<and> (\<forall>x\<in>{c<..b}. \<phi> x < \<psi> x))"
     (is "?th2")
 *)
   unfolding atomize_conj
   apply (cases "a \<le> b")
    defer subgoal by simp
 proof -
   assume "a \<le> b"
   note \<phi>_cont = has_real_derivative_imp_continuous_on[OF \<phi>']
   note \<psi>_cont = has_real_derivative_imp_continuous_on[OF \<psi>']
   from local_lipschitz_compact_bicomposeE[OF ll cf compact_Icc abX \<phi>_cont \<psi>_cont \<phi>_in \<psi>_in]
   obtain L where L: "L > 0" "\<And>x. x \<in> {a..b} \<Longrightarrow> dist (f x (\<phi> x)) (f x (\<psi> x)) \<le> L * dist (\<phi> x) (\<psi> x)" by blast
   define w where "w x = \<psi> x - \<phi> x" for x
 
   have w'[derivative_intros]: "\<And>x. x \<in> {a .. b} \<Longrightarrow> (w has_real_derivative \<psi>' x - \<phi>' x) (at x)"
     using \<phi>' \<psi>'
     by (auto simp: has_vderiv_on_def w_def[abs_def] intro!: derivative_eq_intros)
   note w_cont[continuous_intros] = has_real_derivative_imp_continuous_on[OF w', THEN continuous_on_compose2]
   have "w d \<ge> 0" if "d \<in> {a .. b}" for d
   proof (rule ccontr, unfold not_le)
     assume "w d < 0"
     let ?N = "(w -` {..0} \<inter> {a .. d})"
     from \<open>w d < 0\<close> that have "d \<in> ?N" by auto
     then have "?N \<noteq> {}" by auto
     have "closed ?N"
       unfolding compact_eq_bounded_closed
       using that
       by (intro conjI closed_vimage_Int) (auto intro!: continuous_intros)
 
     let ?N' = "{a0 \<in> {a .. d}. w ` {a0 .. d} \<subseteq> {..0}}"
     from \<open>w d < 0\<close> that have "d \<in> ?N'" by simp
     then have "?N' \<noteq> {}" by auto
     have "compact ?N'"
       unfolding compact_eq_bounded_closed
     proof
       have "?N' \<subseteq> {a .. d}" using that by auto
       then show "bounded ?N'"
         by (rule bounded_subset[rotated]) simp
       have "w u \<le> 0" if "(\<forall>n. x n \<in> ?N')" "x \<longlonglongrightarrow> l" "l \<le> u" "u \<le> d" for x l u
       proof cases
         assume "l = u"
         have "\<forall>n. x n \<in> ?N" using that(1) by force
         from closed_sequentially[OF \<open>closed ?N\<close> this \<open>x \<longlonglongrightarrow> l\<close>]
         show ?thesis by (auto simp: \<open>l = u\<close>)
       next
         assume "l \<noteq> u" with that have "l < u" by auto
         from order_tendstoD(2)[OF \<open>x \<longlonglongrightarrow> l\<close> \<open>l < u\<close>] obtain n where "x n < u"
           by (auto dest: eventually_happens)
         with that show ?thesis using \<open>l < u\<close>
           by (auto dest!: spec[where x=n] simp: image_subset_iff)
       qed
       then show "closed ?N'"
         unfolding closed_sequential_limits
         by (auto simp: Lim_bounded Lim_bounded2)
     qed
 
     from compact_attains_inf[OF \<open>compact ?N'\<close> \<open>?N' \<noteq> {}\<close>]
     obtain a0 where a0: "a \<le> a0" "a0 \<le> d" "w ` {a0..d} \<subseteq> {..0}"
       and a0_least: "\<And>x. a \<le> x \<Longrightarrow> x \<le> d \<Longrightarrow> w ` {x..d} \<subseteq> {..0} \<Longrightarrow> a0 \<le> x"
       by auto
     have a0d: "{a0 .. d} \<subseteq> {a .. b}" using that a0
       by auto
     have L_w_bound: "L * w x \<le> \<psi>' x - \<phi>' x" if "x \<in> {a0 .. d}" for x
     proof -
       from set_mp[OF a0d that] have "x \<in> {a .. b}" .
       from defect[OF this]
       have "\<phi>' x - \<psi>' x \<le> dist (f x (\<phi> x)) (f x (\<psi> x))"
         by (simp add: dist_real_def)
       also have "\<dots> \<le> L * dist (\<phi> x) (\<psi> x)"
         using \<open>x \<in> {a .. b}\<close>
         by (rule L)
       also have "\<dots> \<le> -L * w x"
         using \<open>0 < L\<close> a0 that
-        by (force simp add: dist_real_def abs_real_def w_def sign_simps)
+        by (force simp add: dist_real_def abs_real_def w_def algebra_split_simps )
       finally show ?thesis
         by simp
     qed
     have mono: "mono_on (\<lambda>x. w x * exp(-L*x)) {a0..d}"
       apply (rule mono_onI)
       apply (rule DERIV_nonneg_imp_nondecreasing, assumption)
       using a0d
       by (auto intro!: exI[where x="(\<psi>' x - \<phi>' x) * exp (- (L * x)) - exp (- (L * x)) * L * w x" for x]
           derivative_eq_intros L_w_bound simp: )
     then have "w a0 * exp (-L * a0) \<le> w d * exp (-L * d)"
       by (rule mono_onD) (use that a0 in auto)
-    also have "\<dots> < 0" using \<open>w d < 0\<close> by (simp add: sign_simps)
+    also have "\<dots> < 0" using \<open>w d < 0\<close> by (simp add: algebra_split_simps)
     finally have "w a0 * exp (- L * a0) < 0" .
-    then have "w a0 < 0" by (simp add: sign_simps)
+    then have "w a0 < 0" by (simp add: algebra_split_simps)
     have "a0 \<le> a"
     proof (rule ccontr, unfold not_le)
       assume "a < a0"
       have "continuous_on {a.. a0} w"
         by (rule continuous_intros, assumption) (use a0 a0d in auto)
       from continuous_on_Icc_at_leftD[OF this \<open>a < a0\<close>]
       have "(w \<longlongrightarrow> w a0) (at_left a0)" .
       from order_tendstoD(2)[OF this \<open>w a0 < 0\<close>] have "\<forall>\<^sub>F x in at_left a0. w x < 0" .
       moreover have "\<forall>\<^sub>F x in at_left a0. a < x"
         by (rule order_tendstoD) (auto intro!: \<open>a < a0\<close>)
       ultimately have "\<forall>\<^sub>F x in at_left a0. a < x \<and> w x < 0" by eventually_elim auto
       then obtain a1' where "a1'<a0" and a1_neg: "\<And>y. y > a1' \<Longrightarrow> y < a0 \<Longrightarrow> a < y \<and> w y < 0"
         unfolding eventually_at_left_field by auto
       define a1 where "a1 = (a1' + a0)/2"
       have "a1 < a0" using \<open>a1' < a0\<close> by (auto simp: a1_def)
       have "a \<le> a1"
         using \<open>a < a0\<close> a1_neg by (force simp: a1_def)
       moreover have "a1 \<le> d"
         using \<open>a1' < a0\<close> a0(2) by (auto simp: a1_def)
       moreover have "w ` {a1..a0} \<subseteq> {..0}"
         using \<open>w a0 < 0\<close> a1_neg a0(3)
         by (auto simp: a1_def) smt
       moreover have "w ` {a0..d} \<subseteq> {..0}" using a0 by auto
       ultimately
       have "a0 \<le> a1"
         apply (intro a0_least) apply assumption apply assumption
         by (smt atLeastAtMost_iff image_subset_iff)
       with \<open>a1<a0\<close> show False by simp
     qed
     then have "a0 = a" using \<open>a \<le> a0\<close> by simp
     with \<open>w a0 < 0\<close> have "w a < 0" by simp
     with init show False
       by (auto simp: w_def)
   qed
   then show ?thesis
     by (auto simp: w_def)
 qed
 
 lemma local_lipschitz_mult:
   shows "local_lipschitz  (UNIV::real set) (UNIV::real set) (*)"
   apply (auto intro!: c1_implies_local_lipschitz[where f'="\<lambda>p. blinfun_mult_left (fst p)"])
-   apply (simp add: Complex_Analysis_Basics.has_derivative_mult_right mult_commute_abs)
+   apply (simp add: has_derivative_mult_right mult_commute_abs)
   by (auto intro!: continuous_intros)
 
 lemma comparison_principle_le_linear:
   fixes \<phi> :: "real \<Rightarrow> real"
   assumes "continuous_on {a..b} g"
   assumes "(\<And>t. t \<in> {a..b} \<Longrightarrow> (\<phi> has_real_derivative \<phi>' t) (at t))"
   assumes "\<phi> a \<le> 0"
   assumes "(\<And>t. t \<in> {a..b} \<Longrightarrow> \<phi>' t \<le> g t *\<^sub>R \<phi> t)"
   shows "\<forall>t\<in>{a..b}. \<phi> t \<le> 0"
 proof -
   have *: "\<And>x. continuous_on {a..b} (\<lambda>t. g t * x)"
     using assms(1) continuous_on_mult_right by blast
   then have "local_lipschitz (g`{a..b}) UNIV (*)"
     using local_lipschitz_subset[OF local_lipschitz_mult] by blast 
   from local_lipschitz_compose1[OF this assms(1)]
   have "local_lipschitz {a..b} UNIV (\<lambda>t. (*) (g t))" .
   from comparison_principle_le[OF this _ _ assms(2) _ _ _ assms(3), of b "\<lambda>t.0"] * assms(4)
   show ?thesis by auto
 qed
 
 subsection \<open>Locally Lipschitz ODEs\<close>
 
 context ll_on_open_it begin
 
 lemma flow_lipschitzE:
   assumes "{a .. b} \<subseteq> existence_ivl t0 x"
   obtains L where "L-lipschitz_on {a .. b} (flow t0 x)"
 proof -
   have f': "(flow t0 x has_derivative (\<lambda>i. i *\<^sub>R f t (flow t0 x t))) (at t within {a .. b})" if "t \<in> {a .. b}" for t
     using flow_has_derivative[of t x] assms that
     by (auto simp: has_derivative_at_withinI)
 
   have "compact ((\<lambda>t. f t (flow t0 x t)) ` {a .. b})"
     using assms
     apply (auto intro!: compact_continuous_image continuous_intros)
     using local.existence_ivl_empty2 apply fastforce
      apply (meson atLeastAtMost_iff general.existence_ivl_subset in_mono)
     by (simp add: general.flow_in_domain subset_iff)
   then obtain C where "t \<in> {a .. b} \<Longrightarrow> norm (f t (flow t0 x t)) \<le> C" for t
-    by (force dest!: compact_imp_bounded simp: bounded_iff image_iff)
+    by (fastforce dest!: compact_imp_bounded simp: bounded_iff intro: that)
   then have "t \<in> {a..b} \<Longrightarrow> onorm (\<lambda>i. i *\<^sub>R f t (flow t0 x t)) \<le> max 0 C" for t
     apply (subst onorm_scaleR_left) 
      apply (auto simp: onorm_id max_def)
     by (metis diff_0_right diff_mono diff_self norm_ge_zero)
   from bounded_derivative_imp_lipschitz[OF f' _ this]
   have "(max 0 C)-lipschitz_on {a..b} (flow t0 x)"
     by auto
   then show ?thesis ..
 qed
 
 lemma flow_undefined0: "t \<notin> existence_ivl t0 x \<Longrightarrow> flow t0 x t = 0"
   unfolding flow_def by auto
 
 lemma csols_undefined: "x \<notin> X \<Longrightarrow> csols t0 x = {}"
   apply (auto simp: csols_def)
   using general.existence_ivl_empty2 general.existence_ivl_maximal_segment
   apply blast
   done
 
 lemmas existence_ivl_undefined = existence_ivl_empty2
 
 end
 
 subsection \<open>Reverse flow as Sublocale\<close>
 
 lemma range_preflect_0[simp]: "range (preflect 0) = UNIV"
   by (auto simp: preflect_def)
 lemma range_uminus[simp]: "range uminus = (UNIV::'a::ab_group_add set)"
   by auto
 
 context auto_ll_on_open begin
 
 sublocale rev: auto_ll_on_open "-f" rewrites "-(-f) = f"
    apply unfold_locales
   using auto_local_lipschitz auto_open_domain
   unfolding fun_Compl_def local_lipschitz_minus
   by auto
 
 lemma existence_ivl_eq_rev0: "existence_ivl0 y = uminus ` rev.existence_ivl0 y" for y
   by (auto simp: existence_ivl_eq_rev rev.existence_ivl0_def preflect_def)
 
 lemma rev_existence_ivl_eq0: "rev.existence_ivl0 y = uminus ` existence_ivl0 y" for y
   using uminus_uminus_image[of "rev.existence_ivl0 y"]
   by (simp add: existence_ivl_eq_rev0)
 
 lemma flow_eq_rev0: "flow0 y t = rev.flow0 y (-t)" for y t
   apply (cases "t \<in> existence_ivl0 y")
   subgoal
     apply (subst flow_eq_rev(2), assumption)
     apply (subst rev.flow0_def)
     by (simp add: preflect_def)
   subgoal
     apply (frule flow_undefined0)
     by (auto simp: existence_ivl_eq_rev0 rev.flow_undefined0)
   done
 
 lemma rev_eq_flow: "rev.flow0 y t = flow0 y (-t)" for y t
   apply (subst flow_eq_rev0)
   using uminus_uminus_image[of "rev.existence_ivl0 y"]
   apply -
   apply (subst (asm) existence_ivl_eq_rev0[symmetric])
   by auto
 
 lemma rev_flow_image_eq: "rev.flow0 x ` S = flow0 x ` (uminus ` S)"
   unfolding rev_eq_flow[abs_def]
   by force
 
 lemma flow_image_eq_rev: "flow0 x ` S = rev.flow0 x ` (uminus ` S)"
   unfolding rev_eq_flow[abs_def]
   by force
 
 end
 
 context c1_on_open begin
 
 sublocale rev: c1_on_open "-f" "-f'" rewrites "-(-f) = f" and "-(-f') = f'"
   by (rule c1_on_open_rev) auto
 
 end
 
 context c1_on_open_euclidean begin
 
 sublocale rev: c1_on_open_euclidean "-f" "-f'" rewrites "-(-f) = f" and "-(-f') = f'"
   by unfold_locales auto
 
 end
 
 
 subsection \<open>Autonomous LL ODE : Existence Interval and trapping on the interval\<close>
 
 lemma bdd_above_is_intervalI: "bdd_above I"
   if "is_interval I" "a \<le> b" "a \<in> I" "b \<notin> I" for I::"real set"
   by (meson bdd_above_def is_interval_1 le_cases that) 
 
 lemma bdd_below_is_intervalI: "bdd_below I"
   if "is_interval I" "a \<le> b" "a \<notin> I" "b \<in> I" for I::"real set"
   by (meson bdd_below_def is_interval_1 le_cases that) 
 
 context auto_ll_on_open begin
 
 lemma open_existence_ivl0:
   assumes x : "x \<in> X"
   shows "\<exists>a b. a < 0 \<and> 0 < b \<and> {a..b} \<subseteq> existence_ivl0 x"
 proof -
   have a1:"0 \<in> existence_ivl0 x"
     by (simp add: x)
   have a2: "open (existence_ivl0 x)"
     by (simp add: x)
   from a1 a2 obtain d where "d > 0" "ball 0 d \<subseteq> existence_ivl0 x"
     using openE by blast
   have "{-d/2..d/2} \<subseteq> ball 0 d"
     using \<open>0 < d\<close> dist_norm mem_ball by auto
   thus ?thesis
     by (smt \<open>0 < d\<close> \<open>ball 0 d \<subseteq> existence_ivl0 x\<close> divide_minus_left half_gt_zero order_trans)
 qed
 
 lemma open_existence_ivl':
   assumes x : "x \<in> X"
   obtains a where "a > 0"  "{-a..a} \<subseteq> existence_ivl0 x"
 proof -
   from open_existence_ivl0[OF assms(1)]
   obtain a b where ab: "a < 0" "0 < b" "{a..b} \<subseteq> existence_ivl0 x" by auto
   then have "min (-a) b > 0" by linarith
   have "{-min (-a) b .. min(-a) b} \<subseteq> {a..b}" by auto
   thus ?thesis using ab(3) that[OF \<open>min (-a) b > 0\<close>] by blast
 qed
 
 lemma open_existence_ivl_on_compact:
   assumes C: "C \<subseteq> X" and "compact C" "C \<noteq> {}"
   obtains a where "a > 0" "\<And>x. x \<in> C \<Longrightarrow> {-a..a} \<subseteq> existence_ivl0 x"
 proof -
   from existence_ivl_cballs
   have "\<forall>x\<in>C. \<exists>e>0. \<exists>t>0. \<forall>y\<in>cball x e. cball 0 t\<subseteq>existence_ivl0 y"
     by (metis (full_types) C Int_absorb1 Int_iff UNIV_I)
   then
   obtain d' t' where *:
     "\<forall>x\<in>C. 0 < d' x \<and> t' x > 0 \<and> (\<forall>y\<in>cball x (d' x). cball 0 (t' x) \<subseteq> existence_ivl0 y)"
     by metis
   with compactE_image[OF \<open>compact C\<close>, of C "\<lambda>x. ball x (d' x)"]
   obtain C' where "C' \<subseteq> C" and [simp]: "finite C'" and C_subset: "C \<subseteq> (\<Union>c\<in>C'. ball c (d' c))"
     by force
   from C_subset \<open>C \<noteq> {}\<close> have [simp]: "C' \<noteq> {}" by auto
   define d where "d = Min (d' ` C')"
   define t where "t = Min (t' ` C')"
   have "t > 0" using * \<open>C' \<subseteq> C\<close>
     by (auto simp: t_def)
   moreover have "{-t .. t} \<subseteq> existence_ivl0 x" if "x \<in> C" for x
   proof -
     from C_subset that \<open>C' \<subseteq> C\<close>
     obtain c where c: "c \<in> C'" "x \<in> ball c (d' c)" "c \<in> C" by force
     then have "{-t .. t} \<subseteq> cball 0 (t' c)"
       by (auto simp: abs_real_def t_def minus_le_iff)
     also
     from c have "cball 0 (t' c) \<subseteq> existence_ivl0 x"
       using *[rule_format, OF \<open>c \<in> C\<close>] by auto
     finally show ?thesis .
   qed
   ultimately show ?thesis ..
 qed
 
 definition "trapped_forward x K \<longleftrightarrow> (flow0 x ` (existence_ivl0 x \<inter> {0..}) \<subseteq> K)"
   \<comment> \<open>TODO: use this for backwards trapped, invariant, and all assumptions\<close>
 
 definition "trapped_backward x K \<longleftrightarrow> (flow0 x ` (existence_ivl0 x \<inter> {..0}) \<subseteq> K)"
 
 definition "trapped x K \<longleftrightarrow> trapped_forward x K \<and> trapped_backward x K"
 
 lemma trapped_iff_on_existence_ivl0:
   "trapped x K \<longleftrightarrow> (flow0 x ` (existence_ivl0 x) \<subseteq> K)"
   unfolding trapped_def trapped_forward_def trapped_backward_def
   apply (auto)
   by (metis IntI atLeast_iff atMost_iff image_subset_iff less_eq_real_def linorder_not_less)
 end
 
 context auto_ll_on_open begin
 
 lemma infinite_rev_existence_ivl0_rewrites:
   "{0..} \<subseteq> rev.existence_ivl0 x \<longleftrightarrow> {..0} \<subseteq> existence_ivl0 x"
   "{..0} \<subseteq> rev.existence_ivl0 x \<longleftrightarrow> {0..} \<subseteq> existence_ivl0 x"
    apply (auto simp add: rev.rev_existence_ivl_eq0 subset_iff)
   using neg_le_0_iff_le apply fastforce
   using neg_0_le_iff_le by fastforce
 
 lemma trapped_backward_iff_rev_trapped_forward:
   "trapped_backward x K  \<longleftrightarrow> rev.trapped_forward x K"
   unfolding trapped_backward_def rev.trapped_forward_def
   by (auto simp add: rev_flow_image_eq existence_ivl_eq_rev0 image_subset_iff)
 
 text \<open>If solution is trapped in a compact set at some time
   on its existence interval then it is trapped forever\<close>
 lemma trapped_sol_right:
   \<comment> \<open>TODO: when building on afp-devel (??? outdated):
     \<^url>\<open>https://bitbucket.org/isa-afp/afp-devel/commits/0c3edf9248d5389197f248c723b625c419e4d3eb\<close>\<close>
   assumes "compact K" "K \<subseteq> X"
   assumes "x \<in> X" "trapped_forward x K"
   shows "{0..} \<subseteq> existence_ivl0 x"
 proof (rule ccontr)
   assume "\<not> {0..} \<subseteq> existence_ivl0 x"
   from this obtain t where "0 \<le> t" "t \<notin> existence_ivl0 x" by blast
   then have bdd: "bdd_above (existence_ivl0 x)" 
     by (auto intro!: bdd_above_is_intervalI \<open>x \<in> X\<close>)
   from flow_leaves_compact_ivl_right [OF UNIV_I \<open>x \<in> X\<close> bdd UNIV_I assms(1-2)]
   show False by (metis assms(4) trapped_forward_def IntI atLeast_iff image_subset_iff)
 qed
 
 lemma trapped_sol_right_gen:
   assumes "compact K" "K \<subseteq> X"
   assumes "t \<in> existence_ivl0 x" "trapped_forward (flow0 x t) K"
   shows "{t..} \<subseteq> existence_ivl0 x"
 proof -
   have "x \<in> X"
     using assms(3) local.existence_ivl_empty_iff by fastforce 
   have xtk: "flow0 x t \<in> X"
     by (simp add: assms(3) local.flow_in_domain)
   from trapped_sol_right[OF assms(1-2) xtk assms(4)] have "{0..} \<subseteq> existence_ivl0 (flow0 x t)" .
   thus "{t..} \<subseteq> existence_ivl0 x"
     using existence_ivl_trans[OF assms(3)]
     by (metis add.commute atLeast_iff diff_add_cancel le_add_same_cancel1 subset_iff)
 qed
 
 lemma trapped_sol_left:
   \<comment> \<open>TODO: when building on afp-devel:
     \<^url>\<open>https://bitbucket.org/isa-afp/afp-devel/commits/0c3edf9248d5389197f248c723b625c419e4d3eb\<close>\<close>
   assumes "compact K" "K \<subseteq> X"
   assumes "x \<in> X" "trapped_backward x K"
   shows "{..0} \<subseteq> existence_ivl0 x"
 proof (rule ccontr)
   assume "\<not> {..0} \<subseteq> existence_ivl0 x"
   from this obtain t where "t \<le> 0" "t \<notin> existence_ivl0 x" by blast
   then have bdd: "bdd_below (existence_ivl0 x)" 
     by (auto intro!: bdd_below_is_intervalI \<open>x \<in> X\<close>)
   from flow_leaves_compact_ivl_left [OF UNIV_I \<open>x \<in> X\<close> bdd UNIV_I assms(1-2)]
   show False
     by (metis IntI assms(4) atMost_iff auto_ll_on_open.trapped_backward_def auto_ll_on_open_axioms image_subset_iff)
 qed
 
 lemma trapped_sol_left_gen:
   assumes "compact K" "K \<subseteq> X"
   assumes "t \<in> existence_ivl0 x" "trapped_backward (flow0 x t) K"
   shows "{..t} \<subseteq> existence_ivl0 x"
 proof -
   have "x \<in> X"
     using assms(3) local.existence_ivl_empty_iff by fastforce 
   have xtk: "flow0 x t \<in> X"
     by (simp add: assms(3) local.flow_in_domain)
   from trapped_sol_left[OF assms(1-2) xtk assms(4)] have "{..0} \<subseteq> existence_ivl0 (flow0 x t)" .
   thus "{..t} \<subseteq> existence_ivl0 x"
     using existence_ivl_trans[OF assms(3)]
     by (metis add.commute add_le_same_cancel1 atMost_iff diff_add_cancel subset_eq)
 qed
 
 lemma trapped_sol:
   assumes "compact K" "K \<subseteq> X"
   assumes "x \<in> X" "trapped x K"
   shows "existence_ivl0 x = UNIV"
   by (metis (mono_tags, lifting) assms existence_ivl_zero image_subset_iff interval local.existence_ivl_initial_time_iff local.existence_ivl_subset local.subset_mem_compact_implies_subset_existence_interval order_refl subset_antisym trapped_iff_on_existence_ivl0)
 
 (* Follows from rectification *)
 lemma regular_locally_noteq:\<comment> \<open>TODO: should be true in \<open>ll_on_open_it\<close>\<close>
   assumes "x \<in> X" "f x \<noteq> 0"
   shows "eventually (\<lambda>t. flow0 x t \<noteq> x) (at 0)"
 proof -
   have nf:"norm (f x) > 0" by (simp add: assms(2)) 
       (* By continuity of solutions and f probably *)
   obtain a where
     a: "a>0"
     "{-a--a} \<subseteq> existence_ivl0 x"
     "0 \<in> {-a--a}"
     "\<And>t. t \<in> {-a--a} \<Longrightarrow> norm(f (flow0 x t) - f (flow0 x 0)) \<le> norm(f x)/2"
   proof -
     from open_existence_ivl'[OF assms(1)]
     obtain a1 where a1: "a1 > 0" "{-a1..a1} \<subseteq> existence_ivl0 x" .
     have "continuous (at 0) (\<lambda>t. norm(f (flow0 x t) - f (flow0 x 0) ))"
       apply (auto intro!: continuous_intros)
       by (simp add: assms(1) local.f_flow_continuous)
     then obtain a2 where "a2>0"
       "\<forall>t. norm t < a2 \<longrightarrow>
              norm (f (flow0 x t) - f (flow0 x 0)) < norm(f x)/2"
       unfolding continuous_at_real_range
       by (metis abs_norm_cancel cancel_comm_monoid_add_class.diff_cancel diff_zero half_gt_zero nf norm_zero)
     then have 
       t: "\<And>t. t \<in> {-a2<--<a2} \<Longrightarrow> norm(f (flow0 x t) - f (flow0 x 0)) \<le> norm(f x)/2"
       by (smt open_segment_bound(2) open_segment_bound1 real_norm_def)
     define a where "a = min a1 (a2/2)"
     have t1:"a > 0" unfolding a_def using \<open>a1 > 0\<close> \<open>a2 > 0\<close> by auto
     then have t3:"0 \<in>{-a--a}"
-      using Starlike.closed_segment_eq_real_ivl by auto  
+      using closed_segment_eq_real_ivl by auto
     have "{-a--a} \<subseteq> {-a1..a1}" unfolding a_def using \<open>a1 > 0\<close> \<open>a2 > 0\<close>
       using ODE_Auxiliarities.closed_segment_eq_real_ivl by auto
     then have t2:"{-a--a} \<subseteq> existence_ivl0 x" using a1 by auto
     have "{-a--a} \<subseteq> {-a2<--<a2}" unfolding a_def using \<open>a1 > 0\<close> \<open>a2 > 0\<close>
-      by (smt Diff_iff Starlike.closed_segment_eq_real_ivl atLeastAtMost_iff empty_iff half_gt_zero insert_iff pos_half_less segment(1) subset_eq)
+      by (smt Diff_iff closed_segment_eq_real_ivl atLeastAtMost_iff empty_iff half_gt_zero insert_iff pos_half_less segment(1) subset_eq)
     then have t4:"\<And>t. t \<in> {-a--a} \<Longrightarrow> norm(f (flow0 x t) - f (flow0 x 0)) \<le> norm(f x)/2" using t by auto
     show ?thesis using t1 t2 t3 t4 that by auto
   qed
   have "\<And>t. t \<in> {-a--a} \<Longrightarrow> (flow0 x has_vector_derivative f (flow0 x t)) (at t within {-a--a})"
     apply (rule has_vector_derivative_at_within)
     using a(2) by (auto intro!:flow_has_vector_derivative)
   from vector_differentiable_bound_linearization[OF this _ a(4)]
   have nb:"\<And>c d. {c--d} \<subseteq> {-a--a} \<Longrightarrow>
    norm (flow0 x d - flow0 x c - (d - c) *\<^sub>R f (flow0 x 0))  \<le> norm (d - c) * (norm (f x) / 2)"
     using a(3) by blast
   have "\<And>t. dist t 0 < a \<Longrightarrow> t \<noteq> 0 \<Longrightarrow> flow0 x t \<noteq> x"
   proof (rule ccontr)
     fix t
     assume "dist t 0 < a" "t \<noteq> 0" "\<not> flow0 x t \<noteq> x"
     then have tx:"flow0 x t = x" by auto
     have "t \<in> {-a--a}"
-      using Starlike.closed_segment_eq_real_ivl \<open>dist t 0 < a\<close> by auto 
+      using closed_segment_eq_real_ivl \<open>dist t 0 < a\<close> by auto
     have "t > 0 \<or> t < 0" using \<open>t \<noteq> 0\<close> by linarith
     moreover {
       assume "t > 0"
       then have "{0--t} \<subseteq> {-a--a}"
         by (simp add: \<open>t \<in> {-a--a}\<close> a(3) subset_closed_segment) 
       from nb[OF this] have
         "norm (flow0 x t - x - t *\<^sub>R f x) \<le> norm t * (norm (f x) / 2)"
         by (simp add: assms(1))
       then have "norm (t *\<^sub>R f x) \<le> norm t * (norm (f x) / 2)" using tx by auto
       then have False using nf
         using \<open>0 < t\<close> by auto 
     }
     moreover {
       assume "t < 0"
       then have "{t--0} \<subseteq> {-a--a}"
         by (simp add: \<open>t \<in> {-a--a}\<close> a(3) subset_closed_segment) 
       from nb[OF this] have
         "norm (x - flow0 x t + t *\<^sub>R f x) \<le> norm t * (norm (f x) / 2)"
         by (simp add: assms(1))
       then have "norm (t *\<^sub>R f x) \<le> norm t * (norm (f x) / 2)" using tx by auto
       then have False using nf
         using \<open>t < 0\<close> by auto 
     }
     ultimately show False by blast
   qed
   thus ?thesis unfolding eventually_at
     using a(1) by blast
 qed
 
 lemma compact_max_time_flow_in_closed:
   assumes "closed M" and t_ex: "t \<in> existence_ivl0 x"
   shows "compact {s \<in> {0..t}. flow0 x ` {0..s} \<subseteq> M}" (is "compact ?C")
   unfolding compact_eq_bounded_closed
 proof
   have "bounded {0 .. t}" by auto
   then show "bounded ?C"
     by (rule bounded_subset) auto
   show "closed ?C"
     unfolding closed_def
   proof (rule topological_space_class.openI, clarsimp)
     \<comment> \<open>TODO: there must be a more abstract argument for this, e.g., with
       @{thm continuous_on_closed_vimageI} and then reasoning about the connected component around 0?\<close>
     fix s
     assume notM: "s \<le> t \<longrightarrow> 0 \<le> s \<longrightarrow> \<not> flow0 x ` {0..s} \<subseteq> M"
     consider "0 \<le> s" "s \<le> t" "flow0 x s \<notin> M" | "0 \<le> s" "s \<le> t" "flow0 x s \<in> M" | "s < 0" | "s > t"
       by arith
     then show "\<exists>T. open T \<and> s \<in> T \<and> T \<subseteq> - {s. 0 \<le> s \<and> s \<le> t \<and> flow0 x ` {0..s} \<subseteq> M}"
     proof cases
       assume s: "0 \<le> s" "s \<le> t" and sM: "flow0 x s \<notin> M"
       have "isCont (flow0 x) s"
         using s ivl_subset_existence_ivl[OF t_ex]
         by (auto intro!: flow_continuous)
       from this[unfolded continuous_at_open, rule_format, of "-M"] sM \<open>closed M\<close>
       obtain S where "open S" "s \<in> S" "(\<forall>x'\<in>S. flow0 x x' \<in> - M)"
         by auto
       then show ?thesis
         by (force intro!: exI[where x=S])
     next
       assume s: "0 \<le> s" "s \<le> t" and sM: "flow0 x s \<in> M"
       from this notM obtain s0 where s0: "0 \<le> s0" "s0 < s" "flow0 x s0 \<notin> M"
         by force
       from order_tendstoD(1)[OF tendsto_ident_at \<open>s0 < s\<close>, of UNIV, unfolded eventually_at_topological]
       obtain S where "open S" "s \<in> S" "\<And>x. x \<in> S \<Longrightarrow> x \<noteq> s \<Longrightarrow> s0 < x"
         by auto
       then show ?thesis using s0
         by (auto simp: intro!: exI[where x=S]) (smt atLeastAtMost_iff image_subset_iff)
     qed (force intro: exI[where x="{t<..}"] exI[where x="{..<0}"])+
   qed
 qed
 
 lemma flow_in_closed_max_timeE:
   assumes "closed M" "t \<in> existence_ivl0 x" "0 \<le> t" "x \<in> M"
   obtains T where "0 \<le> T" "T \<le> t" "flow0 x ` {0..T} \<subseteq> M"
     "\<And>s'. 0 \<le> s' \<Longrightarrow> s' \<le> t \<Longrightarrow> flow0 x ` {0..s'} \<subseteq> M \<Longrightarrow> s' \<le> T"
 proof -
   let ?C = "{s \<in> {0..t}. flow0 x ` {0..s} \<subseteq> M}"
   have "?C \<noteq> {}"
     using assms
     using local.mem_existence_ivl_iv_defined
     by (auto intro!: exI[where x=0])
   from compact_max_time_flow_in_closed[OF assms(1,2)]
   have "compact ?C" .
   from compact_attains_sup[OF this \<open>?C \<noteq> {}\<close>]
   obtain s where s: "0 \<le> s" "s \<le> t" "flow0 x ` {0..s} \<subseteq> M"
     and s_max: "\<And>s'. 0 \<le> s' \<Longrightarrow> s' \<le> t \<Longrightarrow> flow0 x ` {0..s'} \<subseteq> M \<Longrightarrow> s' \<le> s"
     by auto
   then show ?thesis ..
 qed
 
 lemma flow_leaves_closed_at_frontierE:
   assumes "closed M" and t_ex: "t \<in> existence_ivl0 x" and "0 \<le> t" "x \<in> M" "flow0 x t \<notin> M"
   obtains s where "0 \<le> s" "s < t" "flow0 x ` {0..s} \<subseteq> M"
     "flow0 x s \<in> frontier M"
     "\<exists>\<^sub>F s' in at_right s. flow0 x s' \<notin> M"
 proof -
   from flow_in_closed_max_timeE[OF assms(1-4)] assms(5)
   obtain s where s: "0 \<le> s" "s < t" "flow0 x ` {0..s} \<subseteq> M"
     and s_max: "\<And>s'. 0 \<le> s' \<Longrightarrow> s' \<le> t \<Longrightarrow> flow0 x ` {0..s'} \<subseteq> M \<Longrightarrow> s' \<le> s"
     by (smt atLeastAtMost_iff image_subset_iff)
   note s
   moreover
   have "flow0 x s \<notin> interior M"
   proof
     assume interior: "flow0 x s \<in> interior M"
     have "s \<in> existence_ivl0 x" using ivl_subset_existence_ivl[OF \<open>t \<in> _\<close>] s by auto
     from flow_continuous[OF this, THEN isContD, THEN topological_tendstoD, OF open_interior interior]
     have "\<forall>\<^sub>F s' in at s. flow0 x s' \<in> interior M" by auto
     then have "\<forall>\<^sub>F s' in at_right s. flow0 x s' \<in> interior M"
       by (auto simp: eventually_at_split)
     moreover have "\<forall>\<^sub>F s' in at_right s. s' < t"
       using tendsto_ident_at \<open>s < t\<close>
       by (rule order_tendstoD)
     ultimately have "\<forall>\<^sub>F s' in at_right s. flow0 x s' \<in> M \<and> s' < t"
       by eventually_elim (use interior_subset[of M] in auto)
     then obtain s' where s': "s < s'" "s' < t" "\<And>y. y > s \<Longrightarrow> y \<le> s' \<Longrightarrow> flow0 x y \<in> M"
       by (auto simp: eventually_at_right_field_le)
     have s'_ivl: "flow0 x ` {0..s'} \<subseteq> M"
     proof safe
       fix s'' assume "s'' \<in> {0 .. s'}"
       then show "flow0 x s'' \<in> M"
         using s interior_subset[of M] s'
         by (cases "s'' \<le> s") auto
     qed
     with s_max[of s'] \<open>s' < t\<close> \<open>0 \<le> s\<close> \<open>s < s'\<close> show False by auto
   qed
   then have "flow0 x s \<in> frontier M"
     using s closure_subset[of M]
     by (force simp: frontier_def)
   moreover
   have "compact (flow0 x -` M \<inter> {s..t})" (is "compact ?C")
     unfolding compact_eq_bounded_closed
   proof
     have "bounded {s .. t}" by simp
     then show "bounded ?C"
       by (rule bounded_subset) auto
     show "closed ?C"
       using \<open>closed M\<close> assms mem_existence_ivl_iv_defined(2)[OF t_ex] ivl_subset_existence_ivl[OF t_ex] \<open>0 \<le> s\<close>
       by (intro closed_vimage_Int) (auto intro!: continuous_intros)
   qed
   have "\<exists>\<^sub>F s' in at_right s. flow0 x s' \<notin> M"
     apply (rule ccontr)
     unfolding not_frequently
   proof -
     assume "\<forall>\<^sub>F s' in at_right s. \<not> flow0 x s' \<notin> M"
     moreover have "\<forall>\<^sub>F s' in at_right s. s' < t"
       using tendsto_ident_at \<open>s < t\<close>
       by (rule order_tendstoD)
     ultimately have "\<forall>\<^sub>F s' in at_right s. flow0 x s' \<in> M \<and> s' < t" by eventually_elim auto
     then obtain s' where s': "s < s'"
       "\<And>y. y > s \<Longrightarrow> y < s' \<Longrightarrow> flow0 x y \<in> M"
       "\<And>y. y > s \<Longrightarrow> y < s' \<Longrightarrow> y < t"
       by (auto simp: eventually_at_right_field)
     define s'' where "s'' = (s + s') / 2"
     have "0 \<le> s''" "s'' \<le> t"  "s < s''" "s'' < s'"
       using s s'
       by (auto simp del: divide_le_eq_numeral1 le_divide_eq_numeral1 simp: s''_def) fastforce
     then have "flow0 x ` {0..s''} \<subseteq> M"
       using s s'
       apply (auto simp: )
       subgoal for u
         by (cases "u\<le>s") auto
       done
     from s_max[OF \<open>0 \<le> s''\<close> \<open>s''\<le> t\<close> this] \<open>s'' > s\<close>
     show False by simp
   qed
   ultimately show ?thesis ..
 qed
 
 
 subsection \<open>Connectedness\<close>
 
 lemma fcontX:
   shows "continuous_on X f"
   using auto_local_lipschitz local_lipschitz_continuous_on by blast
 
 lemma fcontx:
   assumes "x \<in> X"
   shows "continuous (at x) f"
 proof -
   have "open X" by simp
   from continuous_on_eq_continuous_at[OF this]
   show ?thesis using fcontX assms(1) by blast
 qed
 
 lemma continuous_at_imp_cball:
   assumes "continuous (at x) g"
   assumes "g x > (0::real)"
   obtains r where "r > 0" "\<forall>y \<in> cball x r. g y > 0"
 proof -
   from assms(1)
   obtain d where "d>0" "g ` (ball x d) \<subseteq> ball (g x) ((g x)/2)"
     by (meson assms(2) continuous_at_ball half_gt_zero)
   then have "\<forall>y \<in> cball x (d/2). g y > 0"
     by (smt assms(2) dist_norm image_subset_iff mem_ball mem_cball pos_half_less real_norm_def)
   thus ?thesis
     using \<open>0 < d\<close> that half_gt_zero by blast
 qed
 
 text \<open> \<open>flow0\<close> is \<open>path_connected\<close> \<close>
 lemma flow0_path_connected_time:
   assumes "ts \<subseteq> existence_ivl0 x" "path_connected ts"
   shows "path_connected (flow0 x ` ts)"
 proof -
   have "continuous_on ts (flow0 x)"
     by (meson assms continuous_on_sequentially flow_continuous_on subsetD)
   from path_connected_continuous_image[OF this assms(2)] 
   show ?thesis .
 qed
 
 lemma flow0_path_connected:
   assumes "path_connected D"
     "path_connected ts"
     "\<And>x. x \<in> D \<Longrightarrow> ts \<subseteq> existence_ivl0 x"
   shows "path_connected ( (\<lambda>(x, y). flow0 x y) ` (D \<times> ts))"
 proof -
   have "D \<times> ts \<subseteq> Sigma X existence_ivl0"
     using assms(3) subset_iff by fastforce
   then have a1:"continuous_on (D \<times> ts) (\<lambda>(x, y). flow0 x y)"
     using flow_continuous_on_state_space continuous_on_subset by blast 
   have a2 : "path_connected (D \<times> ts)" using path_connected_Times assms by auto
   from path_connected_continuous_image[OF a1 a2]
   show ?thesis .
 qed
 
 end
 
 subsection \<open>Return Time and Implicit Function Theorem\<close>
 
 context c1_on_open_euclidean begin
 
 lemma flow_implicit_function:
   \<comment> \<open>TODO: generalization of @{thm returns_to_implicit_function}!\<close>
   fixes s::"'a::euclidean_space \<Rightarrow> real" and S::"'a set"
   assumes t: "t \<in> existence_ivl0 x" and x: "x \<in> X" and st: "s (flow0 x t) = 0"
   assumes Ds: "\<And>x. (s has_derivative blinfun_apply (Ds x)) (at x)"
   assumes DsC: "isCont Ds (flow0 x t)"
   assumes nz: "Ds (flow0 x t) (f (flow0 x t)) \<noteq> 0"
   obtains u e
   where "s (flow0 x (u x)) = 0"
     "u x = t"
     "(\<And>y. y \<in> cball x e \<Longrightarrow> s (flow0 y (u y)) = 0)"
     "continuous_on (cball x e) u"
     "(\<lambda>t. (t, u t)) ` cball x e \<subseteq> Sigma X existence_ivl0"
     "0 < e" "(u has_derivative (- blinfun_scaleR_left
                    (inverse (blinfun_apply (Ds (flow0 x t)) (f (flow0 x t)))) o\<^sub>L
                       (Ds (flow0 x t) o\<^sub>L flowderiv x t) o\<^sub>L embed1_blinfun)) (at x)"
 proof -
   note [derivative_intros] = has_derivative_compose[OF _ Ds]
   have cont_s: "continuous_on UNIV s" by (rule has_derivative_continuous_on[OF Ds])
   note cls[simp, intro] = closed_levelset[OF cont_s]
   then have xt1: "(x, t) \<in> Sigma X existence_ivl0"
     by (auto simp: t x)
   have D: "(\<And>x. x \<in> Sigma X existence_ivl0 \<Longrightarrow>
       ((\<lambda>(x, t). s (flow0 x t)) has_derivative
        blinfun_apply (Ds (flow0 (fst x) (snd x)) o\<^sub>L (flowderiv (fst x) (snd x))))
        (at x))"
     by (auto intro!: derivative_eq_intros)
   have C: "isCont (\<lambda>x. Ds (flow0 (fst x) (snd x)) o\<^sub>L flowderiv (fst x) (snd x))
    (x, t)"
     using flowderiv_continuous_on[unfolded continuous_on_eq_continuous_within,
         rule_format, OF xt1]
     using at_within_open[OF xt1 open_state_space]
     by (auto intro!: continuous_intros tendsto_eq_intros x t
         isCont_tendsto_compose[OF DsC, unfolded poincare_map_def]
         simp: split_beta' isCont_def)
   have Z: "(case (x, t) of (x, t) \<Rightarrow> s (flow0 x t)) = 0"
     by (auto simp: st)
   have I1: "blinfun_scaleR_left (inverse (Ds (flow0 x t)(f (flow0 x t)))) o\<^sub>L 
     ((Ds (flow0 (fst (x, t))
             (snd (x, t))) o\<^sub>L
        flowderiv (fst (x, t))
         (snd (x, t))) o\<^sub>L
       embed2_blinfun)
      = 1\<^sub>L"
     using nz
     by (auto intro!: blinfun_eqI
         simp: flowderiv_def blinfun.bilinear_simps inverse_eq_divide poincare_map_def)
   have I2: "((Ds (flow0 (fst (x, t))
             (snd (x, t))) o\<^sub>L
        flowderiv (fst (x, t))
         (snd (x, t))) o\<^sub>L
       embed2_blinfun) o\<^sub>L blinfun_scaleR_left (inverse (Ds (flow0 x t)(f (flow0 x t))))
      = 1\<^sub>L"
     using nz
     by (auto intro!: blinfun_eqI
         simp: flowderiv_def blinfun.bilinear_simps inverse_eq_divide poincare_map_def)
   show ?thesis
     apply (rule implicit_function_theorem[where f="\<lambda>(x, t). s (flow0 x t)"
           and S="Sigma X existence_ivl0", OF D xt1 open_state_space order_refl C Z I1 I2])
      apply blast
     unfolding split_beta' fst_conv snd_conv poincare_map_def[symmetric]
     ..
 qed
 
 lemma flow_implicit_function_at:
   fixes s::"'a::euclidean_space \<Rightarrow> real" and S::"'a set"
   assumes x: "x \<in> X" and st: "s x = 0"
   assumes Ds: "\<And>x. (s has_derivative blinfun_apply (Ds x)) (at x)"
   assumes DsC: "isCont Ds x"
   assumes nz: "Ds x (f x) \<noteq> 0"
   assumes pos: "e > 0"
   obtains u d
   where
     "0 < d"
     "u x = 0"
     "\<And>y. y \<in> cball x d \<Longrightarrow> s (flow0 y (u y)) = 0"
     "\<And>y. y \<in> cball x d \<Longrightarrow> \<bar>u y\<bar> < e"
     "\<And>y. y \<in> cball x d \<Longrightarrow> u y \<in> existence_ivl0 y"
     "continuous_on (cball x d) u"
     "(u has_derivative -Ds x /\<^sub>R (Ds x) (f x)) (at x)"
 proof -
   have x0: "flow0 x 0 = x" by (simp add: x)
   from flow_implicit_function[OF existence_ivl_zero[OF x] x, unfolded x0, of s, OF st Ds DsC nz]
   obtain u d0 where
     s0: "s (flow0 x (u x)) = 0"
     and u0: "u x = 0"
     and u: "\<And>y. y \<in> cball x d0 \<Longrightarrow> s (flow0 y (u y)) = 0"
     and uc: "continuous_on (cball x d0) u"
     and uex: "(\<lambda>t. (t, u t)) ` cball x d0 \<subseteq> Sigma X existence_ivl0"
     and d0: "0 < d0"
     and u': "(u has_derivative
      blinfun_apply
       (- blinfun_scaleR_left (inverse (blinfun_apply (Ds x) (f x))) o\<^sub>L (Ds x o\<^sub>L flowderiv x 0) o\<^sub>L embed1_blinfun))
      (at x)"
     by blast
   have "at x within cball x d0 = at x" by (rule at_within_interior) (auto simp: \<open>0 < d0\<close>)
   then have "(u \<longlongrightarrow> 0) (at x)"
     using uc d0 by (auto simp: continuous_on_def u0 dest!: bspec[where x=x])
   from tendstoD[OF this \<open>0 < e\<close>] pos u0
   obtain d1 where d1: "0 < d1" "\<And>xa. dist xa x \<le> d1 \<Longrightarrow> \<bar>u xa\<bar> < e"
     unfolding eventually_at_le
     by force
   define d where "d = min d0 d1"
   have "0 < d" by (auto simp: d_def d0 d1)
   moreover note u0
   moreover have "\<And>y. y \<in> cball x d \<Longrightarrow> s (flow0 y (u y)) = 0" by (auto intro!: u simp: d_def)
   moreover have "\<And>y. y \<in> cball x d \<Longrightarrow> \<bar>u y\<bar> < e" using d1 by (auto simp: d_def dist_commute)
   moreover have "\<And>y. y \<in> cball x d \<Longrightarrow> u y \<in> existence_ivl0 y"
     using uex by (force simp: d_def)
   moreover have "continuous_on (cball x d) u"
     using uc by (rule continuous_on_subset) (auto simp: d_def)
   moreover
   have "(u has_derivative -Ds x /\<^sub>R (Ds x) (f x)) (at x)"
     using u'
     by (rule has_derivative_subst) (auto intro!: ext simp: x x0 flowderiv_def blinfun.bilinear_simps)
   ultimately show ?thesis ..
 qed
 
 lemma returns_to_implicit_function_gen:
   \<comment> \<open>TODO: generalizes proof of @{thm returns_to_implicit_function}!\<close>
   fixes s::"'a::euclidean_space \<Rightarrow> real"
   assumes rt: "returns_to {x \<in> S. s x = 0} x" (is "returns_to ?P x")
   assumes cS: "closed S"
   assumes Ds: "\<And>x. (s has_derivative blinfun_apply (Ds x)) (at x)"
     "isCont Ds (poincare_map ?P x)"
     "Ds (poincare_map ?P x) (f (poincare_map ?P x)) \<noteq> 0"
   obtains u e
   where "s (flow0 x (u x)) = 0"
     "u x = return_time ?P x"
     "(\<And>y. y \<in> cball x e \<Longrightarrow> s (flow0 y (u y)) = 0)"
     "continuous_on (cball x e) u"
     "(\<lambda>t. (t, u t)) ` cball x e \<subseteq> Sigma X existence_ivl0"
     "0 < e" "(u has_derivative (- blinfun_scaleR_left
                    (inverse (blinfun_apply (Ds (poincare_map ?P x)) (f (poincare_map ?P x)))) o\<^sub>L
                       (Ds (poincare_map ?P x) o\<^sub>L flowderiv x (return_time ?P x)) o\<^sub>L embed1_blinfun)) (at x)"
 proof -
   note [derivative_intros] = has_derivative_compose[OF _ Ds(1)]
   have cont_s: "continuous_on UNIV s" by (rule has_derivative_continuous_on[OF Ds(1)])
   note cls[simp, intro] = closed_levelset[OF cont_s]
   let ?t1 = "return_time ?P x"
   have cls[simp, intro]: "closed {x \<in> S. s x = 0}"
     by (rule closed_levelset_within) (auto intro!: cS continuous_on_subset[OF cont_s])
 
   have *: "poincare_map ?P x = flow0 x (return_time {x \<in> S. s x = 0} x)"
     by (simp add: poincare_map_def)
   have "return_time {x \<in> S. s x = 0} x \<in> existence_ivl0 x"
     "x \<in> X"
     "s (poincare_map ?P x) = 0"
     using poincare_map_returns rt
     by (auto intro!: return_time_exivl rt)
   note E = flow_implicit_function[of "return_time ?P x" x s Ds, OF this[unfolded *] Ds[unfolded *],
       folded *]
   show ?thesis
     by (rule E) rule
 qed
 
 text \<open>c.f. Perko Section 3.7 Lemma 2 part 1.\<close>
 
 lemma flow_transversal_surface_finite_intersections:
   fixes s::"'a \<Rightarrow> 'b::real_normed_vector"
     and Ds::"'a \<Rightarrow> 'a \<Rightarrow>\<^sub>L 'b"
   assumes "closed S"
   assumes "\<And>x. (s has_derivative (Ds x)) (at x)"
   assumes "\<And>x. x \<in> S \<Longrightarrow> s x = 0 \<Longrightarrow> Ds x (f x) \<noteq> 0"
   assumes "a \<le> b" "{a .. b} \<subseteq> existence_ivl0 x"
   shows "finite {t\<in>{a..b}. flow0 x t \<in> {x \<in> S. s x = 0}}"
     \<comment> \<open>TODO: define notion of (compact/closed)-(continuous/differentiable/C1)-surface?\<close>
 proof cases
   note Ds = \<open>\<And>x. (s has_derivative (Ds x)) (at x)\<close>
   note transversal = \<open>\<And>x. x \<in> S \<Longrightarrow> s x = 0 \<Longrightarrow> Ds x (f x) \<noteq> 0\<close>
   assume "a < b"
   show ?thesis
   proof (rule ccontr)
     let ?S = "{x \<in> S. s x = 0}"
     let ?T = "{t\<in>{a..b}. flow0 x t \<in> {x \<in> S. s x = 0}}"
     define \<phi> where "\<phi> = flow0 x"
     have [THEN continuous_on_compose2, continuous_intros]: "continuous_on S s"
       by (auto simp: intro!: has_derivative_continuous_on Ds intro: has_derivative_at_withinI)
     assume "infinite ?T"
     from compact_sequentialE[OF compact_Icc[of a b] this]
     obtain t tl where t: "t n \<in> ?T" "flow0 x (t n) \<in> ?S" "t n \<in> {a .. b}" "t n \<noteq> tl"
       and tl: "t \<longlonglongrightarrow> tl" "tl \<in> {a..b}"
     for n
       by force
     have tl_ex: "tl \<in> existence_ivl0 x" using \<open>{a .. b} \<subseteq> existence_ivl0 x\<close> \<open>tl \<in> {a .. b}\<close> by auto
     have "closed ?S"
       by (auto intro!: closed_levelset_within \<open>closed S\<close> continuous_intros)
     moreover
     have "\<forall>n. flow0 x (t n) \<in> ?S"
       using t by auto
     moreover
     have flow_t: "(\<lambda>n. flow0 x (t n)) \<longlonglongrightarrow> flow0 x tl"
       by (auto intro!: tendsto_eq_intros tl_ex tl)
     ultimately have "flow0 x tl \<in> ?S"
       by (rule closed_sequentially)
 
     let ?qt = "\<lambda>t. (flow0 x t - flow0 x tl) /\<^sub>R (t - tl)"
     from flow_has_vector_derivative[OF tl_ex, THEN has_vector_derivative_withinD]
     have qt_tendsto: "?qt \<midarrow>tl\<rightarrow> f (flow0 x tl)" .
     let ?q = "\<lambda>n. ?qt (t n)"
     have "filterlim t (at tl) sequentially"
       using tl(1)
       by (rule filterlim_atI) (simp add: t)
     with qt_tendsto have "?q \<longlonglongrightarrow> f (flow0 x tl)"
       by (rule filterlim_compose)
     then have "((\<lambda>n. Ds (flow0 x tl) (?q n))) \<longlonglongrightarrow> Ds (flow0 x tl) (f (flow0 x tl))"
       by (auto intro!: tendsto_intros)
     moreover
 
     from flow_lipschitzE[OF \<open>{a .. b} \<subseteq> existence_ivl0 x\<close>] obtain L' where L': "L'-lipschitz_on {a..b} (flow0 x)" .
     define L where "L = L' + 1"
     from lipschitz_on_le[OF L', of L] lipschitz_on_nonneg[OF L']
     have L: "L-lipschitz_on {a .. b} (flow0 x)" and "L > 0"
       by (auto simp: L_def)
     from flow_lipschitzE[OF \<open>{a .. b} \<subseteq> existence_ivl0 x\<close>] obtain L' where "L'-lipschitz_on {a..b} (flow0 x)" .
         \<comment> \<open>TODO: is this reasoning (below) with this Lipschitz constant really necessary?\<close>
     have s[simp]: "s (flow0 x (t n)) = 0""s (flow0 x tl) = 0"
       for n
       using t \<open>flow0 x tl \<in> ?S\<close>
       by auto
 
     from Ds(1)[of "flow0 x tl", unfolded has_derivative_within]
     have "(\<lambda>y. (1 / norm (y - flow0 x tl)) *\<^sub>R (s y - (s (flow0 x tl) + blinfun_apply (Ds (flow0 x tl)) (y - flow0 x tl)))) \<midarrow>flow0 x tl\<rightarrow> 0"
       by auto
     then have "((\<lambda>y. (1 / norm (y - flow0 x tl)) *\<^sub>R (s y - (s (flow0 x tl) + blinfun_apply (Ds (flow0 x tl)) (y - flow0 x tl)))) \<longlongrightarrow> 0)
       (nhds (flow0 x tl))"
       by (rule tendsto_nhds_continuousI) simp
 
     from filterlim_compose[OF this flow_t]
     have "(\<lambda>xa. (blinfun_apply (Ds (flow0 x tl)) (flow0 x (t xa) - flow0 x tl)) /\<^sub>R norm (flow0 x (t xa) - flow0 x tl))
       \<longlonglongrightarrow> 0"
       using t
       by (auto simp: inverse_eq_divide tendsto_minus_cancel_right)
     from tendsto_mult[OF tendsto_const[of "L"] tendsto_norm[OF this, simplified, simplified divide_inverse_commute[symmetric]]]\<comment> \<open>TODO: uuugly\<close>
     have Ds0: "(\<lambda>xa. norm (blinfun_apply (Ds (flow0 x tl)) (flow0 x (t xa) - flow0 x tl)) / (norm (flow0 x (t xa) - flow0 x tl)/(L))) \<longlonglongrightarrow> 0"
       by (auto simp: ac_simps)
 
     from _ Ds0 have "((\<lambda>n. Ds (flow0 x tl) (?q n)) \<longlonglongrightarrow> 0)"
       apply (rule Lim_null_comparison)
       apply (rule eventuallyI)
       unfolding norm_scaleR blinfun.scaleR_right abs_inverse divide_inverse_commute[symmetric]
       subgoal for n
         apply (cases "flow0 x (t n) = flow0 x tl")
         subgoal by (simp add: blinfun.bilinear_simps)
         subgoal
           apply (rule divide_left_mono)
           using lipschitz_onD[OF L, of "t n" tl] \<open>0 < L\<close> t(3) tl(2)
-          by (auto simp: sign_simps zero_less_divide_iff dist_norm pos_divide_le_eq
+          by (auto simp: algebra_split_simps zero_less_divide_iff dist_norm pos_divide_le_eq
               intro!: add_pos_nonneg)
         done
       done
     ultimately have "Ds (flow0 x tl) (f (flow0 x tl)) = 0"
       by (rule LIMSEQ_unique)
     moreover have "Ds (flow0 x tl) (f (flow0 x tl)) \<noteq> 0"
       by (rule transversal) (use \<open>flow0 x tl \<in> ?S\<close> in auto)
     ultimately show False by auto
   qed
 qed (use assms in auto)
 
 lemma uniform_limit_flow0_state:\<comment> \<open>TODO: is that something more general?\<close>
   assumes "compact C"
   assumes "C \<subseteq> X"
   shows "uniform_limit C (\<lambda>s x. flow0 x s) (\<lambda>x. flow0 x 0) (at 0)"
 proof (cases "C = {}")
   case True then show ?thesis by auto
 next
   case False show ?thesis
   proof (rule uniform_limitI)
     fix e::real assume "0 < e"
     {
       fix x assume "x \<in> C"
       with assms have "x \<in> X" by auto
       from existence_ivl_cballs[OF UNIV_I \<open>x \<in> X\<close>]
       obtain t L u where "\<And>y. y \<in> cball x u \<Longrightarrow> cball 0 t \<subseteq> existence_ivl0 y"
         "\<And>s y. y \<in> cball x u \<Longrightarrow> s \<in> cball 0 t \<Longrightarrow> flow0 y s \<in> cball y u"
         "L-lipschitz_on (cball 0 t\<times>cball x u) (\<lambda>(t, x). flow0 x t)"
         "\<And>y. y \<in> cball x u \<Longrightarrow> cball y u \<subseteq> X"
         "0 < t" "0 < u"
         by metis
       then have "\<exists>L. \<exists>u>0. \<exists>t>0. L-lipschitz_on (cball 0 t\<times>cball x u) (\<lambda>(t, x). flow0 x t)" by blast
     } then have "\<forall>x\<in>C. \<exists>L. \<exists>u>0. \<exists>t>0. L-lipschitz_on (cball 0 t\<times>cball x u) (\<lambda>(t, x). flow0 x t)" ..
     then obtain L d' u' where
       L: "\<And>x. x \<in> C \<Longrightarrow> (L x)-lipschitz_on (cball 0 (d' x)\<times>cball x (u' x)) (\<lambda>(t, x). flow0 x t)"
       and d': "\<And>x. x \<in> C \<Longrightarrow> d' x > 0"
       and u': "\<And>x. x \<in> C \<Longrightarrow> u' x > 0"
       by metis
     have "C \<subseteq> (\<Union>c\<in>C. ball c (u' c))" using u' by auto
     from compactE_image[OF \<open>compact C\<close> _ this]
     obtain C' where "C' \<subseteq> C" and [simp]: "finite C'" and C'_cover: "C \<subseteq> (\<Union>c\<in>C'. ball c (u' c))"
       by auto
     from C'_cover obtain c' where c': "x \<in> C \<Longrightarrow> x \<in> ball (c' x) (u' (c' x))" "x \<in> C \<Longrightarrow> c' x \<in> C'" for x
       by (auto simp: subset_iff) metis
     have "\<forall>\<^sub>F s in at 0. \<forall>x\<in>ball c (u' c). dist (flow0 x s) (flow0 x 0) < e" if "c \<in> C'" for c
     proof -
       have cC: "c \<in> C"
         using c' \<open>c \<in> C'\<close> d' \<open>C' \<subseteq> C\<close>
         by auto
       have *: "dist (flow0 x s) (flow0 x 0) \<le> L c * \<bar>s\<bar>"
         if "x\<in>ball c (u' c)"
           "s \<in> cball 0 (d' c)"
         for x s
       proof -
         from L[OF cC, THEN lipschitz_onD, of "(0, x)" "(s, x)"] d'[OF cC] that
         show ?thesis
           by (auto simp: dist_prod_def dist_commute)
       qed
       have "\<forall>\<^sub>F s in at 0. abs s < d' c"
         by (rule order_tendstoD tendsto_intros)+ (use d' cC in auto)
       moreover have "\<forall>\<^sub>F s in at 0. L c * \<bar>s\<bar> < e"
         by (rule order_tendstoD tendsto_intros)+ (use \<open>0 < e\<close> in auto)
       ultimately show ?thesis
         apply eventually_elim
         apply (use * in auto)
         by smt
     qed
     then have "\<forall>\<^sub>F s in at 0. \<forall>c\<in>C'. \<forall>x\<in>ball c (u' c). dist (flow0 x s) (flow0 x 0) < e"
       by (simp add: eventually_ball_finite_distrib)
     then show "\<forall>\<^sub>F s in at 0. \<forall>x\<in>C. dist (flow0 x s) (flow0 x 0) < e"
       apply eventually_elim
       apply (auto simp: )
       subgoal for s x
         apply (drule bspec[where x="c' x"])
          apply (simp add: c'(2))
         apply (drule bspec) prefer 2 apply assumption
         apply auto
         using c'(1) by auto
       done
   qed
 qed
 
 end
 
 subsection \<open>Fixpoints\<close>
 
 context auto_ll_on_open begin
 
 lemma fixpoint_sol:
   assumes "x \<in> X" "f x = 0"
   shows "existence_ivl0 x = UNIV" "flow0 x t = x"
 proof -
   have sol: "((\<lambda>t::real. x) solves_ode (\<lambda>_. f)) UNIV X"
     apply (rule solves_odeI)
     by(auto simp add: assms intro!: derivative_intros)
   from maximal_existence_flow[OF sol] have
     "UNIV \<subseteq> existence_ivl0 x" "flow0 x t = x" by auto
   thus "existence_ivl0 x = UNIV" "flow0 x t = x" by auto
 qed
 
 end
 
 end
\ No newline at end of file
diff --git a/thys/Poincare_Bendixson/Poincare_Bendixson.thy b/thys/Poincare_Bendixson/Poincare_Bendixson.thy
--- a/thys/Poincare_Bendixson/Poincare_Bendixson.thy
+++ b/thys/Poincare_Bendixson/Poincare_Bendixson.thy
@@ -1,2824 +1,2821 @@
 section \<open>Poincare Bendixson Theory\<close>
 theory Poincare_Bendixson
   imports 
     Ordinary_Differential_Equations.ODE_Analysis
     Analysis_Misc ODE_Misc Periodic_Orbit
 begin
 
 
 subsection \<open>Flow to Path\<close>
 
 context auto_ll_on_open begin
 
 (* The path along the flow starting at time t to time t' *)
 definition "flow_to_path x t t' = flow0 x \<circ> linepath t t'"
 
 lemma pathstart_flow_to_path[simp]:
   shows "pathstart (flow_to_path x t t') = flow0 x t"
   unfolding flow_to_path_def
   by (auto simp add: pathstart_compose)
 
 lemma pathfinish_flow_to_path[simp]:
   shows "pathfinish (flow_to_path x t t') = flow0 x t'"
   unfolding flow_to_path_def
   by (auto simp add: pathfinish_compose)
 
 lemma flow_to_path_unfold:
   shows "flow_to_path x t t' s = flow0 x ((1 - s) * t + s * t')"
   unfolding flow_to_path_def o_def linepath_def by auto
 
 lemma subpath0_flow_to_path:
   shows "(subpath 0 u (flow_to_path x t t')) = flow_to_path x t (t + u*(t'-t))"
   unfolding flow_to_path_def subpath_image subpath0_linepath
   by auto
 
 lemma path_image_flow_to_path[simp]:
   assumes "t \<le> t'"
   shows "path_image (flow_to_path x t t') = flow0 x ` {t..t'}"
   unfolding flow_to_path_def path_image_compose path_image_linepath
   using assms real_Icc_closed_segment by auto
 
 lemma flow_to_path_image0_right_open[simp]:
   assumes "t < t'"
   shows "flow_to_path x t t' ` {0..<1} = flow0 x `{t..<t'}"
   unfolding flow_to_path_def image_comp[symmetric] linepath_image0_right_open_real[OF assms]
   by auto
 
 lemma flow_to_path_path:
   assumes "t \<le> t'"
   assumes "{t..t'} \<subseteq> existence_ivl0 x"
   shows "path (flow_to_path x t t')"
 proof -
   have "x \<in> X"
     using assms(1) assms(2) subset_empty by fastforce
   have "\<And>xa. 0 \<le> xa \<Longrightarrow> xa \<le> 1 \<Longrightarrow>  (1 - xa) * t + xa * t' \<le> t'"
     by (simp add: assms(1) convex_bound_le)
   moreover have "\<And>xa. 0 \<le> xa \<Longrightarrow> xa \<le> 1 \<Longrightarrow> t \<le> (1 - xa) * t + xa * t'" using assms(1)
     by (metis add.commute add_diff_cancel_left' diff_diff_eq2 diff_le_eq mult.commute mult.right_neutral mult_right_mono right_diff_distrib')
   ultimately have "\<And>xa. 0 \<le> xa \<Longrightarrow> xa \<le> 1 \<Longrightarrow> (1 - xa) * t + xa * t' \<in> existence_ivl0 x"
     using assms(2) by auto
   thus ?thesis unfolding path_def flow_to_path_def linepath_def
     by (auto intro!:continuous_intros simp add :\<open>x \<in> X\<close>)
 qed
 
 lemma flow_to_path_arc:
   assumes "t \<le> t'"
   assumes "{t..t'} \<subseteq> existence_ivl0 x"
   assumes "\<forall>s \<in> {t<..<t'}. flow0 x s \<noteq> flow0 x t"
   assumes "flow0 x t \<noteq> flow0 x t'"
   shows "arc (flow_to_path x t t')"
   unfolding arc_def
 proof safe
   from flow_to_path_path[OF assms(1-2)]
   show "path (flow_to_path x t t')" .
 next
   show "inj_on (flow_to_path x t t') {0..1}"
     unfolding flow_to_path_def
     apply (rule comp_inj_on)
      apply (metis assms(4) inj_on_linepath)
     using assms path_image_linepath[of t t'] apply (auto intro!:flow0_inj_on)
     using flow0_inj_on greaterThanLessThan_iff linepath_image_01 real_Icc_closed_segment by fastforce
 qed
 
 end
 
 locale c1_on_open_R2 = c1_on_open_euclidean f f' X for f::"'a::executable_euclidean_space \<Rightarrow> _" and f' and X +
   assumes dim2: "DIM('a) = 2"
 begin
 
 
 subsection \<open>2D Line segments\<close>
 
 text \<open>Line segments are specified by two endpoints
       The closed line segment from x to y is given by the set {x--y}
       and {x<--<y} for the open segment\<close>
 
 text \<open> Rotates a vector clockwise 90 degrees \<close>
 definition "rot (v::'a) = (eucl_of_list [nth_eucl v 1, -nth_eucl v 0]::'a)"
 
 lemma exhaust2_nat: "(\<forall>i<(2::nat). P i) \<longleftrightarrow> P 0 \<and> P 1"
   using less_2_cases by auto
 lemma sum2_nat: "(\<Sum>i<(2::nat). P i) = P 0 + P 1"
   by (simp add: eval_nat_numeral)
 
 lemmas vec_simps =
   eucl_eq_iff[where 'a='a] dim2 eucl_of_list_eucl_nth exhaust2_nat
   plus_nth_eucl
   minus_nth_eucl
   uminus_nth_eucl
   scaleR_nth_eucl
   inner_nth_eucl
   sum2_nat
   algebra_simps
 
 lemma minus_expand:
   shows "(x::'a)-y = (eucl_of_list [x$\<^sub>e0 - y$\<^sub>e0, x$\<^sub>e1 - y$\<^sub>e1])"
   by (simp add:vec_simps)
 
 lemma dot_ortho[simp]: "x \<bullet> rot x = 0"
   unfolding rot_def minus_expand
   by (simp add: vec_simps)
 
 lemma nrm_dot:
   shows "((x::'a)-y) \<bullet> (rot (x-y)) = 0"
   unfolding rot_def minus_expand
   by (simp add: vec_simps)
 
 lemma nrm_reverse: "a \<bullet> (rot (x-y)) = - a \<bullet> (rot (y-x))" for x y::'a
   unfolding rot_def
   by (simp add:vec_simps)
 
 lemma norm_rot: "norm (rot v) = norm v" for v::'a
   unfolding rot_def
   by (simp add:vec_simps norm_nth_eucl L2_set_def)
 
 lemma rot_rot[simp]:
   shows "rot (rot v) = -v"
   unfolding rot_def
   by (simp add:vec_simps)
 
 lemma rot_scaleR[simp]:
   shows "rot ( u *\<^sub>R v) =  u *\<^sub>R (rot v)"
   unfolding rot_def
   by (simp add:vec_simps)
 
 lemma rot_0[simp]: "rot 0 = 0"
   using rot_scaleR[of 0] by simp
 
 lemma rot_eq_0_iff[simp]: "rot x = 0 \<longleftrightarrow> x = 0"
   apply (auto simp: rot_def)
    apply (metis One_nat_def norm_eq_zero norm_rot norm_zero rot_def)
   using rot_0 rot_def by auto
 
 lemma in_segment_inner_rot:
   "(x - a) \<bullet> rot (b - a) = 0"
   if "x \<in> {a--b}"
 proof -
   from that obtain u where x: "x = a + u *\<^sub>R (b - a)" "0 \<le> u" "u \<le> 1"
     by (auto simp: in_segment algebra_simps)
   show ?thesis
     unfolding x
     by (simp add: inner_add_left nrm_dot)
 qed
 
 lemma inner_rot_in_segment:
   "x \<in> range (\<lambda>u. a + u *\<^sub>R (b - a))"
   if "(x - a) \<bullet> rot (b - a) = 0" "a \<noteq> b"
 proof -
   from that have
     x0: "b $\<^sub>e 0 = a $\<^sub>e 0 \<Longrightarrow> x $\<^sub>e 0 =
       (a $\<^sub>e 0 * b $\<^sub>e Suc 0 - b $\<^sub>e 0 * a $\<^sub>e Suc 0 + (b $\<^sub>e 0 - a $\<^sub>e 0) * x $\<^sub>e Suc 0) /
       (b $\<^sub>e Suc 0 - a $\<^sub>e Suc 0)"
     and x1: "b $\<^sub>e 0 \<noteq> a $\<^sub>e 0 \<Longrightarrow> x $\<^sub>e Suc 0 =
       ((b $\<^sub>e Suc 0 - a $\<^sub>e Suc 0) * x $\<^sub>e 0 - a $\<^sub>e 0 * b $\<^sub>e Suc 0 + b $\<^sub>e 0 * a $\<^sub>e Suc 0) / (b $\<^sub>e 0 - a $\<^sub>e 0)"
     by (auto simp: rot_def vec_simps divide_simps)
   define u where "u = (if b $\<^sub>e 0 - a $\<^sub>e 0 \<noteq> 0
     then ((x $\<^sub>e 0 - a $\<^sub>e 0) / (b $\<^sub>e 0 -  a $\<^sub>e 0))
     else ((x $\<^sub>e 1 - a $\<^sub>e 1) / (b $\<^sub>e 1 -  a $\<^sub>e 1)))
     "
   show ?thesis
     apply (cases "b $\<^sub>e 0 - a $\<^sub>e 0 = 0")
     subgoal
       using that(2)
       apply (auto intro!: image_eqI[where x="((x $\<^sub>e 1 - a $\<^sub>e 1) / (b $\<^sub>e 1 -  a $\<^sub>e 1))"]
           simp: vec_simps x0 divide_simps algebra_simps)
        apply (metis ab_semigroup_mult_class.mult_ac(1) mult.commute sum_sqs_eq)
       by (metis mult.commute mult.left_commute sum_sqs_eq)
     subgoal
       apply (auto intro!: image_eqI[where x="((x $\<^sub>e 0 - a $\<^sub>e 0) / (b $\<^sub>e 0 -  a $\<^sub>e 0))"]
           simp: vec_simps x1 divide_simps algebra_simps)
        apply (metis ab_semigroup_mult_class.mult_ac(1) mult.commute sum_sqs_eq)
       by (metis mult.commute mult.left_commute sum_sqs_eq)
     done
 qed
 
 lemma in_open_segment_iff_rot:
   "x \<in> {a<--<b} \<longleftrightarrow> (x - a) \<bullet> rot (b - a) = 0 \<and> x \<bullet> (b - a) \<in> {a\<bullet>(b - a) <..< b \<bullet> (b - a)}"
   if "a \<noteq> b"
   unfolding open_segment_line_hyperplanes[OF that]
   by (auto simp: nrm_dot intro!: inner_rot_in_segment)
 
 lemma in_open_segment_rotD:
   "x \<in> {a<--<b} \<Longrightarrow> (x - a) \<bullet> rot (b - a) = 0 \<and> x \<bullet> (b - a) \<in> {a\<bullet>(b - a) <..< b \<bullet> (b - a)}"
   by (subst in_open_segment_iff_rot[symmetric]) auto
 
 lemma in_closed_segment_iff_rot:
   "x \<in> {a--b} \<longleftrightarrow> (x - a) \<bullet> rot (b - a) = 0 \<and> x \<bullet> (b - a) \<in> {a\<bullet>(b - a) .. b \<bullet> (b - a)}"
   if "a \<noteq> b"
   unfolding closed_segment_line_hyperplanes[OF that] using that
   by (auto simp: nrm_dot intro!: inner_rot_in_segment)
 
 lemma in_segment_inner_rot2:
   "(x - y) \<bullet> rot (a - b) = 0"
   if "x \<in> {a--b}" "y \<in> {a--b}"
 proof -
   from that obtain u where x: "x = a + u *\<^sub>R (b - a)" "0 \<le> u" "u \<le> 1"
     by (auto simp: in_segment algebra_simps)
   from that obtain v where y: "y = a + v *\<^sub>R (b - a)" "0 \<le> v" "v \<le> 1"
     by (auto simp: in_segment algebra_simps)
   show ?thesis
     unfolding x y
     apply (auto simp: inner_add_left )
     by (smt add_diff_cancel_left' in_segment_inner_rot inner_diff_left minus_diff_eq nrm_reverse that(1) that(2) x(1) y(1))
 qed
 
 lemma closed_segment_surface:
   "a \<noteq> b \<Longrightarrow> {a--b} = { x \<in> {x. x \<bullet> (b - a) \<in> {a\<bullet>(b - a) .. b \<bullet> (b - a)}}. (x - a) \<bullet> rot (b - a) = 0}"
   by (auto simp: in_closed_segment_iff_rot)
 
 lemma rot_diff_commute: "rot (b - a) = -rot(a - b)"
   apply (auto simp: rot_def algebra_simps)
   by (metis One_nat_def minus_diff_eq rot_def rot_rot)
 
 
 subsection \<open>Bijection Real-Complex for Jordan Curve Theorem\<close>
 
 definition "complex_of (x::'a) = x$\<^sub>e0 + \<i> * x$\<^sub>e1"
 
 definition "real_of (x::complex) = (eucl_of_list [Re x, Im x]::'a)"
 
 lemma complex_of_linear:
   shows "linear complex_of"
   unfolding complex_of_def
   apply (auto intro!:linearI simp add: distrib_left plus_nth_eucl)
   by (simp add: of_real_def scaleR_add_right scaleR_nth_eucl)
 
 lemma complex_of_bounded_linear:
   shows "bounded_linear complex_of"
   unfolding complex_of_def
   apply (auto intro!:bounded_linearI' simp add: distrib_left plus_nth_eucl)
   by (simp add: of_real_def scaleR_add_right scaleR_nth_eucl)
 
 lemma real_of_linear:
   shows "linear real_of"
   unfolding real_of_def
   by (auto intro!:linearI simp add: vec_simps)
 
 lemma real_of_bounded_linear:
   shows "bounded_linear real_of"
   unfolding real_of_def
   by (auto intro!:bounded_linearI' simp add: vec_simps)
 
 lemma complex_of_real_of:
   "(complex_of \<circ> real_of) = id"
   unfolding complex_of_def real_of_def
   using complex_eq by (auto simp add:vec_simps)
 
 lemma real_of_complex_of:
   "(real_of \<circ> complex_of) = id"
   unfolding complex_of_def real_of_def
   using complex_eq by (auto simp add:vec_simps)
 
 lemma complex_of_bij:
   shows "bij (complex_of)"
   using o_bij[OF real_of_complex_of complex_of_real_of] .
 
 lemma real_of_bij:
   shows "bij (real_of)"
   using o_bij[OF complex_of_real_of real_of_complex_of] .
 
 lemma real_of_inj:
   shows "inj (real_of)"
   using real_of_bij
   using bij_betw_imp_inj_on by auto
 
 lemma Jordan_curve_R2:
   fixes c :: "real \<Rightarrow> 'a"
   assumes "simple_path c" "pathfinish c = pathstart c"
   obtains inside outside where
     "inside \<noteq> {}" "open inside" "connected inside"
     "outside \<noteq> {}" "open outside" "connected outside"
     "bounded inside" "\<not> bounded outside"
     "inside \<inter> outside = {}"
     "inside \<union> outside = - path_image c"
     "frontier inside = path_image c"
     "frontier outside = path_image c"
 proof -
   from simple_path_linear_image_eq[OF complex_of_linear]
   have a1:"simple_path (complex_of \<circ> c)" using assms(1) complex_of_bij
     using bij_betw_imp_inj_on by blast
   have a2:"pathfinish (complex_of \<circ> c) = pathstart (complex_of \<circ> c)"
     using assms(2) by (simp add:pathstart_compose pathfinish_compose)
 
   from Jordan_curve[OF a1 a2]
   obtain inside outside where io:
     "inside \<noteq> {}" "open inside" "connected inside"
     "outside \<noteq> {}" "open outside" "connected outside"
     "bounded inside" "\<not> bounded outside" "inside \<inter> outside = {}"
     "inside \<union> outside = - path_image (complex_of \<circ> c)"
     "frontier inside = path_image (complex_of \<circ> c)"
     "frontier outside = path_image (complex_of \<circ> c)" by blast
   let ?rin = "real_of ` inside"
   let ?rout = "real_of ` outside"
   have i: "inside = complex_of ` ?rin" using complex_of_real_of unfolding image_comp
     by auto
   have o: "outside = complex_of ` ?rout" using complex_of_real_of unfolding image_comp
     by auto
   have c: "path_image(complex_of \<circ> c) = complex_of ` (path_image c)"
     by (simp add: path_image_compose)
   have "?rin \<noteq> {}" using io by auto
   moreover from open_bijective_linear_image_eq[OF real_of_linear real_of_bij]
   have "open ?rin" using io by auto
   moreover from connected_linear_image[OF real_of_linear]
   have "connected ?rin" using io by auto
   moreover have "?rout \<noteq> {}" using io by auto
   moreover from open_bijective_linear_image_eq[OF real_of_linear real_of_bij]
   have "open ?rout" using io by auto
   moreover from connected_linear_image[OF real_of_linear]
   have "connected ?rout" using io by auto
   moreover from bounded_linear_image[OF io(7) real_of_bounded_linear]
   have "bounded ?rin" .
   moreover from bounded_linear_image[OF _ complex_of_bounded_linear]
   have "\<not> bounded ?rout" using io(8) o
     by force
   from image_Int[OF real_of_inj]
   have "?rin \<inter> ?rout = {}" using io(9) by auto
   moreover from bij_image_Compl_eq[OF complex_of_bij]
   have "?rin \<union> ?rout = - path_image c" using io(10) unfolding c
     by (metis id_apply image_Un image_comp image_cong image_ident real_of_complex_of)
   moreover from closure_injective_linear_image[OF real_of_linear real_of_inj]
   have "frontier ?rin = path_image c" using io(11)
     unfolding frontier_closures c
     by (metis \<open>\<And>B A. real_of ` (A \<inter> B) = real_of ` A \<inter> real_of ` B\<close> bij_image_Compl_eq c calculation(9) compl_sup double_compl io(10) real_of_bij)
   moreover from closure_injective_linear_image[OF real_of_linear real_of_inj]
   have "frontier ?rout = path_image c" using io(12)
     unfolding frontier_closures c
     by (metis \<open>\<And>B A. real_of ` (A \<inter> B) = real_of ` A \<inter> real_of ` B\<close> bij_image_Compl_eq c calculation(10) frontier_closures io(11) real_of_bij)
   ultimately show ?thesis
     by (meson \<open>\<not> bounded (real_of ` outside)\<close> that)
 qed
 
 (* copied *)
 corollary Jordan_inside_outside_R2:
   fixes c :: "real \<Rightarrow> 'a"
   assumes "simple_path c" "pathfinish c = pathstart c"
   shows "inside(path_image c) \<noteq> {} \<and>
           open(inside(path_image c)) \<and>
           connected(inside(path_image c)) \<and>
           outside(path_image c) \<noteq> {} \<and>
           open(outside(path_image c)) \<and>
           connected(outside(path_image c)) \<and>
           bounded(inside(path_image c)) \<and>
           \<not> bounded(outside(path_image c)) \<and>
           inside(path_image c) \<inter> outside(path_image c) = {} \<and>
           inside(path_image c) \<union> outside(path_image c) =
           - path_image c \<and>
           frontier(inside(path_image c)) = path_image c \<and>
           frontier(outside(path_image c)) = path_image c"
 proof -
   obtain inner outer
     where *: "inner \<noteq> {}" "open inner" "connected inner"
       "outer \<noteq> {}" "open outer" "connected outer"
       "bounded inner" "\<not> bounded outer" "inner \<inter> outer = {}"
       "inner \<union> outer = - path_image c"
       "frontier inner = path_image c"
       "frontier outer = path_image c"
     using Jordan_curve_R2 [OF assms] by blast
   then have inner: "inside(path_image c) = inner"
     by (metis dual_order.antisym inside_subset interior_eq interior_inside_frontier)
   have outer: "outside(path_image c) = outer"
     using \<open>inner \<union> outer = - path_image c\<close> \<open>inside (path_image c) = inner\<close>
       outside_inside \<open>inner \<inter> outer = {}\<close> by auto
   show ?thesis
     using * by (auto simp: inner outer)
 qed
 
 lemma jordan_points_inside_outside:
   fixes p :: "real \<Rightarrow> 'a"
   assumes "0 < e"
   assumes jordan: "simple_path p" "pathfinish p = pathstart p"
   assumes x: "x \<in> path_image p"
   obtains y z where "y \<in> inside (path_image p)" "y \<in> ball x e" 
     "z \<in> outside (path_image p)" "z \<in> ball x e"
 proof -
   from Jordan_inside_outside_R2[OF jordan]
   have xi: "x \<in> frontier(inside (path_image p))" and
     xo: "x \<in> frontier(outside (path_image p))"
     using x by auto
   obtain y where y:"y \<in> inside (path_image p)" "y \<in> ball x e" using \<open>0 < e\<close> xi
     unfolding frontier_straddle
     by auto
   obtain z where z:"z \<in> outside (path_image p)" "z \<in> ball x e" using \<open>0 < e\<close> xo
     unfolding frontier_straddle
     by auto
   show ?thesis using y z that by blast
 qed  
 
 lemma eventually_at_open_segment:
   assumes "x \<in> {a<--<b}"
   shows "\<forall>\<^sub>F y in at x. (y-a) \<bullet> rot(a-b) = 0 \<longrightarrow> y \<in> {a <--< b}"
 proof -
   from assms have "a \<noteq> b" by auto
   from assms have x: "(x - a) \<bullet> rot (b - a) = 0" "x \<bullet> (b - a) \<in> {a \<bullet> (b - a)<..<b \<bullet> (b - a)}"
     unfolding in_open_segment_iff_rot[OF \<open>a \<noteq> b\<close>]
     by auto
   then have "\<forall>\<^sub>F y in at x. y \<bullet> (b - a) \<in> {a \<bullet> (b - a)<..<b \<bullet> (b - a)}"
     by (intro topological_tendstoD) (auto intro!: tendsto_intros)
   then show ?thesis
     by eventually_elim (auto simp: in_open_segment_iff_rot[OF \<open>a \<noteq> b\<close>] nrm_reverse[of _ a b] algebra_simps dist_commute)
 qed
 
 lemma linepath_ball:
   assumes "x \<in> {a<--<b}"
   obtains e where "e > 0" "ball x e \<inter> {y. (y-a) \<bullet> rot(a-b) = 0} \<subseteq> {a <--< b}"
 proof -
   from eventually_at_open_segment[OF assms] assms
   obtain e where "0 < e" "ball x e \<inter> {y. (y - a) \<bullet> rot (a - b) = 0} \<subseteq> {a<--<b}"
     by (force simp: eventually_at in_open_segment_iff_rot dist_commute)
   then show ?thesis ..
 qed
 
 lemma linepath_ball_inside_outside:
   fixes p :: "real \<Rightarrow> 'a"
   assumes jordan: "simple_path (p +++ linepath a b)" "pathfinish p = a" "pathstart p = b"
   assumes x: "x \<in> {a<--<b}"
   obtains e where "e > 0" "ball x e \<inter> path_image p = {}"
     "ball x e \<inter> {y. (y-a) \<bullet> rot (a-b) > 0} \<subseteq> inside (path_image (p +++ linepath a b)) \<and>
      ball x e \<inter> {y. (y-a) \<bullet> rot (a-b) < 0} \<subseteq> outside (path_image (p +++ linepath a b))
      \<or> 
      ball x e \<inter> {y. (y-a) \<bullet> rot (a-b) < 0} \<subseteq> inside (path_image (p +++ linepath a b)) \<and>
      ball x e \<inter> {y. (y-a) \<bullet> rot (a-b) > 0} \<subseteq> outside (path_image (p +++ linepath a b))"
 proof -
   let ?lp = "p +++ linepath a b"
   have "a \<noteq> b" using x by auto
   have pp:"path p" using jordan path_join pathfinish_linepath simple_path_imp_path
     by fastforce
   have "path_image p \<inter> path_image (linepath a b) \<subseteq> {a,b}"
     using jordan simple_path_join_loop_eq
     by (metis (no_types, lifting) inf_sup_aci(1) insert_commute path_join_path_ends path_linepath simple_path_imp_path simple_path_joinE)
   then have "x \<notin> path_image p" using x unfolding path_image_linepath
     by (metis DiffE Int_iff le_iff_inf open_segment_def)
   then have "\<forall>\<^sub>F y in at x. y \<notin> path_image p"
     by (intro eventually_not_in_closed) (auto simp: closed_path_image \<open>path p\<close>)
   moreover 
   have "\<forall>\<^sub>F y in at x. (y - a) \<bullet> rot (a - b) = 0 \<longrightarrow> y \<in> {a<--<b}"
     by (rule eventually_at_open_segment[OF x])
   ultimately have "\<forall>\<^sub>F y in at x. y \<notin> path_image p \<and> ((y - a) \<bullet> rot (a - b) = 0 \<longrightarrow> y \<in> {a<--<b})"
     by eventually_elim auto
   then obtain e where e: "e > 0" "ball x e \<inter> path_image p = {}"
     "ball x e \<inter> {y. (y - a) \<bullet> rot (a - b) = 0} \<subseteq> {a<--<b}"
     using \<open>x \<notin> path_image p\<close> x in_open_segment_rotD[OF x]
     apply (auto simp: eventually_at subset_iff dist_commute dest!: )
     by (metis Int_iff all_not_in_conv dist_commute mem_ball) 
   have a1: "pathfinish ?lp = pathstart ?lp"
     by (auto simp add: jordan)
   have "x \<in> path_image ?lp"
     using jordan(1) open_closed_segment path_image_join path_join_path_ends simple_path_imp_path x by fastforce
   from jordan_points_inside_outside[OF e(1) jordan(1) a1 this]
   obtain y z where y: "y \<in> inside (path_image ?lp)" "y \<in> ball x e" 
     and z: "z \<in> outside (path_image ?lp)" "z \<in> ball x e" by blast
   have jordancurve:
     "inside (path_image ?lp) \<inter> outside(path_image ?lp) = {}"
     "frontier (inside (path_image ?lp)) = path_image ?lp"
     "frontier (outside (path_image ?lp)) = path_image ?lp"
     using Jordan_inside_outside_R2[OF jordan(1) a1] by auto
   define b1 where "b1 = ball x e \<inter> {y. (y-a) \<bullet> rot (a-b) > 0}"
   define b2 where "b2 = ball x e \<inter> {y. (y-a) \<bullet> rot (a-b) < 0}"
   define b3 where "b3 = ball x e \<inter> {y. (y-a) \<bullet> rot (a-b) = 0}"
   have "path_connected b1" unfolding b1_def
     apply (auto intro!: convex_imp_path_connected convex_Int simp add:inner_diff_left)
     using convex_halfspace_gt[of "a \<bullet> rot (a - b)" "rot(a-b)"] inner_commute
     by (metis (no_types, lifting) Collect_cong)
   have "path_connected b2" unfolding b2_def
     apply (auto intro!: convex_imp_path_connected convex_Int simp add:inner_diff_left)
     using convex_halfspace_lt[of "rot(a-b)" "a \<bullet> rot (a - b)"] inner_commute
     by (metis (no_types, lifting) Collect_cong)
   have "b1 \<inter> path_image(linepath a b) = {}" unfolding path_image_linepath b1_def
     using closed_segment_surface[OF \<open>a \<noteq> b\<close>] in_segment_inner_rot2 by auto 
   then have b1i:"b1 \<inter> path_image ?lp = {}"
     by (metis IntD2 b1_def disjoint_iff_not_equal e(2) inf_sup_aci(1) not_in_path_image_join)
   have "b2 \<inter> path_image(linepath a b) = {}" unfolding path_image_linepath b2_def
     using closed_segment_surface[OF \<open>a \<noteq> b\<close>] in_segment_inner_rot2 by auto 
   then have b2i:"b2 \<inter> path_image ?lp = {}"
     by (metis IntD2 b2_def disjoint_iff_not_equal e(2) inf_sup_aci(1) not_in_path_image_join)
   have bsplit: "ball x e = b1 \<union> b2 \<union> b3"
     unfolding b1_def b2_def b3_def
     by auto
   have "z \<notin> b3"
   proof clarsimp
     assume "z \<in> b3"
     then have "z \<in> {a<--<b}" unfolding b3_def using e by blast
     then have "z \<in> path_image(linepath a b)" by (auto simp add: open_segment_def)
     then have "z \<in> path_image ?lp"
       by (simp add: jordan(2) path_image_join)
     thus False using z
       using inside_Un_outside by fastforce
   qed
   then have z12: "z \<in> b1 \<or> z \<in> b2" using z bsplit by blast
   have "y \<notin> b3"
   proof clarsimp
     assume "y \<in> b3"
     then have "y \<in> {a<--<b}" unfolding b3_def using e by auto
     then have "y \<in> path_image(linepath a b)" by (auto simp add: open_segment_def)
     then have "y \<in> path_image ?lp"
       by (simp add: jordan(2) path_image_join)
     thus False using y
       using inside_Un_outside by fastforce
   qed
   then have "y \<in> b1 \<or> y \<in> b2" using y bsplit by blast
   moreover {
     assume "y \<in> b1"
     then have "b1 \<inter> inside (path_image ?lp) \<noteq> {}" using y by blast
     from path_connected_not_frontier_subset[OF \<open>path_connected b1\<close> this]
     have 1:"b1 \<subseteq> inside (path_image ?lp)" unfolding jordancurve using b1i
       by blast
     then have "z \<in> b2" using jordancurve(1) z(1) z12 by blast
     then have "b2 \<inter> outside (path_image ?lp) \<noteq> {}" using z by blast
     from path_connected_not_frontier_subset[OF \<open>path_connected b2\<close> this]
     have 2:"b2 \<subseteq> outside (path_image ?lp)" unfolding jordancurve using b2i
       by blast
     note conjI[OF 1 2]
   }
   moreover {
     assume "y \<in> b2"
     then have "b2 \<inter> inside (path_image ?lp) \<noteq> {}" using y by blast
     from path_connected_not_frontier_subset[OF \<open>path_connected b2\<close> this]
     have 1:"b2 \<subseteq> inside (path_image ?lp)" unfolding jordancurve using b2i
       by blast
     then have "z \<in> b1" using jordancurve(1) z(1) z12 by blast
     then have "b1 \<inter> outside (path_image ?lp) \<noteq> {}" using z by blast
     from path_connected_not_frontier_subset[OF \<open>path_connected b1\<close> this]
     have 2:"b1 \<subseteq> outside (path_image ?lp)" unfolding jordancurve using b1i
       by blast
     note conjI[OF 1 2]
   } 
   ultimately show ?thesis unfolding b1_def b2_def using that[OF e(1-2)] by auto
 qed
 
 subsection \<open>Transversal Segments\<close>\<comment> \<open>TODO: Transversal surface in Euclidean space?!\<close>
 
 definition "transversal_segment a b \<longleftrightarrow>
   a \<noteq> b \<and> {a--b} \<subseteq> X \<and>
   (\<forall>z \<in> {a--b}. f z \<bullet> rot (a-b) \<noteq> 0)"
 
 lemma transversal_segment_reverse:
   assumes "transversal_segment x y"
   shows "transversal_segment y x"
   unfolding transversal_segment_def
   by (metis (no_types, hide_lams) add.left_neutral add_uminus_conv_diff assms closed_segment_commute inner_diff_left inner_zero_left nrm_reverse transversal_segment_def) 
 
 lemma transversal_segment_commute: "transversal_segment x y \<longleftrightarrow> transversal_segment y x"
   using transversal_segment_reverse by blast
 
 lemma transversal_segment_neg:
   assumes "transversal_segment x y"
   assumes w: "w \<in> {x -- y}" and "f w \<bullet> rot (x-y) < 0"
   shows "\<forall>z \<in> {x--y}. f(z) \<bullet> rot (x-y) < 0"
 proof (rule ccontr)
   assume " \<not> (\<forall>z\<in>{x--y}. f z \<bullet> rot (x-y) < 0)"
   then obtain z where z: "z \<in> {x--y}" "f z \<bullet> rot (x-y) \<ge> 0" by auto
   define ff where "ff = (\<lambda>s. f (w + s *\<^sub>R (z - w)) \<bullet> rot (x-y))"
   have f0:"ff 0 \<le> 0" unfolding ff_def using assms(3)
     by simp 
   have fu:"ff 1 \<ge> 0"
     by (auto simp: ff_def z)
   from assms(2) obtain u where u: "0 \<le> u" "u \<le> 1" "w = (1 - u) *\<^sub>R x + u *\<^sub>R y"
     unfolding in_segment by blast
   have "{x--y} \<subseteq> X" using assms(1) unfolding transversal_segment_def by blast
   then have "continuous_on {0..1} ff" unfolding ff_def 
     using assms(2)
     by (auto intro!:continuous_intros closed_subsegmentI z elim!: set_mp)
   from IVT'[of ff, OF f0 fu zero_le_one this]
   obtain s where s: "s \<ge> 0" "s \<le> 1" "ff s = 0" by blast
   have "w + s *\<^sub>R (z - w) \<in> {x -- y}"
     by (auto intro!: closed_subsegmentI z s w)
   with \<open>ff s = 0\<close> show False
     using s assms(1) unfolding transversal_segment_def ff_def by blast
 qed
 
 lemmas transversal_segment_sign_less = transversal_segment_neg[OF _ ends_in_segment(1)]
 
 lemma transversal_segment_pos:
   assumes "transversal_segment x y"
   assumes w: "w \<in> {x -- y}" "f w \<bullet> rot (x-y) > 0"
   shows "\<forall>z \<in> {x--y}. f(z) \<bullet> rot (x-y) > 0"
   using transversal_segment_neg[OF transversal_segment_reverse[OF assms(1)], of w] w
   by (auto simp: rot_diff_commute[of x y] closed_segment_commute)
 
 lemma transversal_segment_posD:
   assumes "transversal_segment x y"
     and pos: "z \<in> {x -- y}" "f z \<bullet> rot (x - y) > 0"
   shows "x \<noteq> y" "{x--y} \<subseteq> X" "\<And>z. z \<in> {x--y} \<Longrightarrow> f z \<bullet> rot (x-y) > 0"
   using assms(1) transversal_segment_pos[OF assms]
   by (auto simp: transversal_segment_def)
 
 lemma transversal_segment_negD:
   assumes "transversal_segment x y"
     and pos: "z \<in> {x -- y}" "f z \<bullet> rot (x - y) < 0"
   shows "x \<noteq> y" "{x--y} \<subseteq> X" "\<And>z. z \<in> {x--y} \<Longrightarrow> f z \<bullet> rot (x-y) < 0"
   using assms(1) transversal_segment_neg[OF assms]
   by (auto simp: transversal_segment_def)
 
 lemma transversal_segmentE:
   assumes "transversal_segment x y"
   obtains "x \<noteq> y" "{x -- y} \<subseteq> X" "\<And>z. z \<in> {x--y} \<Longrightarrow> f z \<bullet> rot (x - y) > 0"
   |  "x \<noteq> y" "{x -- y} \<subseteq> X" "\<And>z. z \<in> {x--y} \<Longrightarrow> f z \<bullet> rot (y - x) > 0"
 proof (cases "f x \<bullet> rot (x - y) < 0")
   case True
   from transversal_segment_negD[OF assms ends_in_segment(1) True]
   have "x \<noteq> y" "{x -- y} \<subseteq> X" "\<And>z. z \<in> {x--y} \<Longrightarrow> f z \<bullet> rot (y - x) > 0"
     by (auto simp: rot_diff_commute[of x y])
   then show ?thesis ..
 next
   case False
   then have "f x \<bullet> rot (x - y) > 0" using assms
-    by (auto simp: transversal_segment_def sign_simps not_less order.order_iff_strict)
+    by (auto simp: transversal_segment_def algebra_split_simps not_less order.order_iff_strict)
   from transversal_segment_posD[OF assms ends_in_segment(1) this]
   show ?thesis ..
 qed
 
 lemma dist_add_vec:
   shows "dist (x + s *\<^sub>R v) x = abs s * norm v"
   by (simp add: dist_cancel_add1)
 
 lemma transversal_segment_exists:
   assumes "x \<in> X" "f x \<noteq> 0"
   obtains a b where "x \<in> {a<--<b}"
     "transversal_segment a b"
 proof -
   (* Line through x perpendicular to f x *)
   define l where "l = (\<lambda>s::real. x + (s/norm(f x)) *\<^sub>R rot (f x))"
   have "norm (f x) > 0" using assms(2) using zero_less_norm_iff by blast 
   then have distl: "\<forall>s. dist (l s) x = abs s" unfolding l_def dist_add_vec
     by (auto simp add: norm_rot)
   obtain d where d:"d > 0" "cball x d \<subseteq> X"
     by (meson UNIV_I assms(1) local.local_unique_solution)
   then have lb: "l`{-d..d} \<subseteq> cball x d" using distl by (simp add: abs_le_iff dist_commute image_subset_iff)
   from fcontx[OF assms(1)] have "continuous (at x) f" .
   then have c:"continuous (at 0) ((\<lambda>y. (f y \<bullet> f x)) \<circ> l)" unfolding l_def
     by (auto intro!:continuous_intros simp add: assms(2))
   have "((\<lambda>y. f y \<bullet> f x) \<circ> l) 0 > 0" using assms(2) unfolding l_def o_def by auto
   from continuous_at_imp_cball[OF c this]
   obtain r where r:"r > 0" " \<forall>z\<in>cball 0 r. 0 < ((\<lambda>y. f y \<bullet> f x) \<circ> l) z" by blast
   then have rc:"\<forall>z \<in> l`{-r..r}. 0 < f z \<bullet> f x" using real_norm_def by auto 
   define dr where "dr = min r d"
   have t1:"l (-dr) \<noteq> l dr" unfolding l_def dr_def
     by (smt \<open>0 < d\<close> \<open>0 < norm (f x)\<close> \<open>0 < r\<close> add_left_imp_eq divide_cancel_right norm_rot norm_zero scale_cancel_right)
   have "x = midpoint (l (-dr)) (l dr)" unfolding midpoint_def l_def by auto
   then have xin:"x \<in> {l (-dr)<--<(l dr)}" using t1 by auto
       (* TODO: actually this should be equality, but l is affine ...
      also the existing stuff about -- is a little too specific *)
   have lsub:"{l (-dr)--l dr} \<subseteq> l`{-dr..dr}"
   proof safe
     fix z
     assume "z \<in> {l (- dr)--l dr}"
     then obtain u where u: "0 \<le> u" "u \<le> 1" "z = (1 - u) *\<^sub>R (l (-dr)) + u *\<^sub>R (l dr)"
       unfolding in_segment by blast
     then have "z = x - (1-u) *\<^sub>R (dr/norm(f x)) *\<^sub>R rot (f x) + u *\<^sub>R  (dr/norm(f x)) *\<^sub>R rot (f x) "
       unfolding l_def
       by (simp add: l_def scaleR_add_right scale_right_diff_distrib u(3))
     also have "... = x - (1 - 2 * u) *\<^sub>R (dr/norm(f x)) *\<^sub>R rot (f x)"
       by (auto simp add: algebra_simps divide_simps simp flip: scaleR_add_left)
     also have "... =  x + (((2 * u - 1) * dr)/norm(f x)) *\<^sub>R rot (f x)"
       by (smt add_uminus_conv_diff scaleR_scaleR scale_minus_left times_divide_eq_right)
     finally have zeq: "z = l ((2*u-1)*dr)" unfolding l_def .
     have ub: " 2* u - 1 \<le> 1 \<and> -1 \<le>  2* u - 1 " using u by linarith
     thus "z \<in> l ` {- dr..dr}" using zeq
       by (smt atLeastAtMost_iff d(1) dr_def image_eqI mult.commute mult_left_le mult_minus_left r(1)) 
   qed
   have t2: "{l (- dr)--l dr} \<subseteq> X" using lsub
     by (smt atLeastAtMost_iff d(2) dist_commute distl dr_def image_subset_iff mem_cball order_trans)
   have "l (- dr) - l dr = -2 *\<^sub>R (dr/norm(f x)) *\<^sub>R rot (f x)" unfolding l_def
     by (simp add: algebra_simps flip: scaleR_add_left)
   then have req: "rot (l (- dr) - l dr) = (2 * dr/norm(f x)) *\<^sub>R f x"
     by auto (metis add.inverse_inverse rot_rot rot_scaleR)
   have "l`{-dr..dr} \<subseteq> l ` {-r ..r}"
     by (simp add: dr_def image_mono)
   then have "{l (- dr)--l dr} \<subseteq> l ` {-r .. r}" using lsub by auto
   then have "\<forall>z \<in> {l (- dr)--l dr}. 0 < f z \<bullet> f x" using rc by blast
   moreover have "(dr / norm (f x)) > 0"
     using \<open>0 < norm (f x)\<close> d(1) dr_def r(1) by auto 
   ultimately have t3: "\<forall>z \<in> {l (- dr)--l dr}. f z \<bullet> rot (l (- dr)- l dr) > 0" unfolding req
     by (smt divide_divide_eq_right inner_scaleR_right mult_2 norm_not_less_zero scaleR_2 times_divide_eq_left times_divide_eq_right zero_less_divide_iff)
   have "transversal_segment (l (-dr)) (l dr)" using t1 t2 t3 unfolding transversal_segment_def by auto
   thus ?thesis using xin
     using that by auto 
 qed
 
 text \<open>Perko Section 3.7 Lemma 2 part 1.\<close> 
 lemma flow_transversal_segment_finite_intersections:
   assumes "transversal_segment a b"
   assumes "t \<le> t'" "{t .. t'} \<subseteq> existence_ivl0 x"
   shows "finite {s\<in>{t..t'}. flow0 x s \<in> {a--b}}"
 proof -
   from assms have "a \<noteq> b" by (simp add: transversal_segment_def)
   show ?thesis
     unfolding closed_segment_surface[OF \<open>a \<noteq> b\<close>]
     apply (rule flow_transversal_surface_finite_intersections[where Ds="\<lambda>_. blinfun_inner_left (rot (b - a))"])
     by
       (use assms in \<open>auto intro!: closed_Collect_conj closed_halfspace_component_ge closed_halfspace_component_le
         derivative_eq_intros
         simp: transversal_segment_def nrm_reverse[where x=a] in_closed_segment_iff_rot\<close>)
 qed
 
 lemma transversal_bound_posE:
   assumes transversal: "transversal_segment a b"
   assumes direction: "z \<in> {a -- b}" "f z \<bullet> (rot (a - b)) > 0"
   obtains d B where "d > 0" "0 < B"
     "\<And>x y. x \<in> {a -- b} \<Longrightarrow> dist x y \<le> d \<Longrightarrow> f y \<bullet> (rot (a - b)) \<ge> B"
 proof -
   let ?a = "(\<lambda>y. (f y) \<bullet> (rot (a - b)))"
   from transversal_segment_posD[OF transversal direction]
   have seg: "a \<noteq> b" "{a--b} \<subseteq> X" "z \<in> {a--b} \<Longrightarrow> 0 < f z \<bullet> rot (a - b)" for z
     by auto
   {
     fix x
     assume "x \<in> {a--b}"
     then have "x \<in> X" "f x \<noteq> 0" "a \<noteq> b" using transversal by (auto simp: transversal_segment_def)
     then have "?a \<midarrow>x\<rightarrow> ?a x"
       by (auto intro!: tendsto_eq_intros)
     moreover have "?a x > 0"
       using seg \<open>x \<in> {a -- b}\<close> \<open>f x \<noteq> 0\<close>
       by (auto simp: simp del: divide_const_simps
           intro!: divide_pos_pos mult_pos_pos)
     ultimately have "\<forall>\<^sub>F x in at x. ?a x > 0"
       by (rule order_tendstoD)
     moreover have "\<forall>\<^sub>F x in at x. x \<in> X"
       by (rule topological_tendstoD[OF tendsto_ident_at open_dom \<open>x \<in> X\<close>])
     moreover have "\<forall>\<^sub>F x in at x. f x \<noteq> 0"
       by (rule tendsto_imp_eventually_ne tendsto_intros \<open>x \<in> X\<close> \<open>f x \<noteq> 0\<close>)+
     ultimately have "\<forall>\<^sub>F x in at x. ?a x>0 \<and> x \<in> X \<and> f x \<noteq> 0" by eventually_elim auto
     then obtain d where d: "0 < d" "\<And>y. y \<in> cball x d \<Longrightarrow> ?a y > 0 \<and> y \<in> X \<and> f y \<noteq> 0"
       using \<open>?a x > 0\<close> \<open>x \<in> X\<close>
       by (force simp: eventually_at_le dist_commute)
 
     have "continuous_on (cball x d) ?a"
       using d \<open>a \<noteq> b\<close>
       by (auto intro!: continuous_intros)
     from compact_continuous_image[OF this compact_cball]
     have "compact (?a ` cball x d)" .
     from compact_attains_inf[OF this] obtain s where "s \<in> cball x d" "\<forall>x\<in>cball x d. ?a x \<ge> ?a s"
       using \<open>d > 0\<close>
       by auto
     then have "\<exists>d>0. \<exists>b>0. \<forall>x \<in> cball x d. ?a x \<ge> b"
       using d
       by (force simp: intro: exI[where x="?a s"])
   } then obtain dx Bx where dB:
     "\<And>x y. x \<in> {a -- b} \<Longrightarrow> y\<in>cball x (dx x) \<Longrightarrow> ?a y \<ge> Bx x"
     "\<And>x. x \<in> {a -- b} \<Longrightarrow> Bx x > 0"
     "\<And>x. x \<in> {a -- b} \<Longrightarrow> dx x > 0"
     by metis
   define d' where "d' = (\<lambda>x. dx x / 2)"
   have d':
     "\<And>x. x \<in> {a -- b} \<Longrightarrow> \<forall>y\<in>cball x (d' x). ?a y \<ge> Bx x"
     "\<And>x. x \<in> {a -- b} \<Longrightarrow> d' x > 0"
     using dB(1,3) by (force simp: d'_def)+
   have d'B: "\<And>x. x \<in> {a -- b} \<Longrightarrow> \<forall>y\<in>cball x (d' x). ?a y \<ge> Bx x"
     using d' by auto
   have "{a--b} \<subseteq> \<Union>((\<lambda>x. ball x (d' x)) ` {a -- b})"
     using d'(2) by auto
   from compactE_image[OF compact_segment _ this]
   obtain X where X: "X \<subseteq> {a--b}"
     and [simp]: "finite X"
     and cover: "{a--b} \<subseteq> (\<Union>x\<in>X. ball x (d' x))"
     by auto
   have [simp]: "X \<noteq> {}" using X cover by auto
   define d where "d = Min (d' ` X)"
   define B where "B = Min (Bx ` X)"
   have "d > 0"
     using X d'
     by (auto simp: d_def d'_def)
   moreover have "B > 0"
     using X dB
     by (auto simp: B_def simp del: divide_const_simps)
   moreover have "B \<le> ?a y" if "x \<in> {a -- b}" "dist x y \<le> d" for x y
   proof -
     from \<open>x \<in> {a -- b}\<close> obtain xc where xc: "xc \<in> X" "x \<in> ball xc (d' xc)"
       using cover by auto
     have "?a y \<ge> Bx xc"
     proof (rule dB)
       show "xc \<in> {a -- b}" using xc \<open>X \<subseteq> _\<close> by auto
       have "dist xc y \<le> dist xc x + dist x y" by norm
       also have "dist xc x \<le> d' xc" using xc by auto
       also note \<open>dist x y \<le> d\<close>
       also have "d \<le> d' xc"
         using xc
         by (auto simp: d_def)
       also have "d' xc + d' xc = dx xc" by (simp add: d'_def)
       finally show "y \<in> cball xc (dx xc)" by simp
     qed
     also have "B \<le> Bx xc"
       using xc
       unfolding B_def
       by (auto simp: B_def)
     finally (xtrans) show ?thesis .
   qed
   ultimately show ?thesis ..
 qed
 
 lemma transversal_bound_negE:
   assumes transversal: "transversal_segment a b"
   assumes direction: "z \<in> {a -- b}" "f z \<bullet> (rot (a - b)) < 0"
   obtains d B where "d > 0" "0 < B"
     "\<And>x y. x \<in> {a -- b} \<Longrightarrow> dist x y \<le> d \<Longrightarrow> f y \<bullet> (rot (b - a)) \<ge> B"
 proof -
   from direction have "z \<in> {b -- a}" "f z \<bullet> (rot (b - a)) > 0"
     by (auto simp: closed_segment_commute rot_diff_commute[of b a])
   from transversal_bound_posE[OF transversal_segment_reverse[OF transversal] this]
   obtain d B where "d > 0" "0 < B"
     "\<And>x y. x \<in> {a -- b} \<Longrightarrow> dist x y \<le> d \<Longrightarrow> f y \<bullet> (rot (b - a)) \<ge> B"
     by (auto simp: closed_segment_commute)
   then show ?thesis ..
 qed
 
 lemma leaves_transversal_segmentE:
   assumes transversal: "transversal_segment a b"
   obtains T n where "T > 0" "n = a - b \<or> n = b - a"
     "\<And>x. x \<in> {a -- b} \<Longrightarrow> {-T..T} \<subseteq> existence_ivl0 x"
     "\<And>x s. x \<in> {a -- b} \<Longrightarrow> 0 < s \<Longrightarrow> s \<le> T \<Longrightarrow>
     (flow0 x s - x) \<bullet> rot n > 0"
     "\<And>x s. x \<in> {a -- b} \<Longrightarrow> -T \<le> s \<Longrightarrow> s < 0 \<Longrightarrow>
     (flow0 x s - x) \<bullet> rot n < 0"
 proof -
   from transversal_segmentE[OF assms(1)] obtain n
     where n: "n = (a - b) \<or> n = (b - a)"
       and seg: "a \<noteq> b" "{a -- b} \<subseteq> X" "\<And>z. z \<in> {a--b} \<Longrightarrow> f z \<bullet> rot n > 0"
     by metis
   from open_existence_ivl_on_compact[OF \<open>{a -- b} \<subseteq> X\<close>]
   obtain t where "0 < t" and t: "x \<in> {a--b} \<Longrightarrow> {- t..t} \<subseteq> existence_ivl0 x" for x
     by auto
   from n obtain d B where B: "0 < d" "0 < B" "(\<And>x y. x \<in> {a--b} \<Longrightarrow> dist x y \<le> d \<Longrightarrow> B \<le> f y \<bullet> rot n)"
   proof
     assume n_def: "n = a - b"
     with seg have pos:  "0 < f a \<bullet> rot (a - b)"
       by auto
     from transversal_bound_posE[OF transversal ends_in_segment(1) pos, folded n_def]
     show ?thesis using that by blast
   next
     assume n_def: "n = b - a"
     with seg have pos:  "0 > f a \<bullet> rot (a - b)"
       by (auto simp: rot_diff_commute[of a b])
     from transversal_bound_negE[OF transversal ends_in_segment(1) this, folded n_def]
     show ?thesis using that by blast
   qed
   define S where "S = \<Union>((\<lambda>x. ball x d) ` {a -- b})"
   have S: "x \<in> S \<Longrightarrow> B \<le> f x \<bullet> rot n" for x
     by (auto simp: S_def intro!: B)
   have "open S" by (auto simp: S_def)
   have "{a -- b} \<subseteq> S"
     by (auto simp: S_def \<open>0 < d\<close>)
   have "\<forall>\<^sub>F (t, x) in at (0, x). flow0 x t \<in> S" if "x \<in> {a -- b}" for x
     unfolding split_beta'
     apply (rule topological_tendstoD tendsto_intros)+
     using set_mp[OF \<open>{a -- b} \<subseteq> X\<close> that] \<open>0 < d\<close> that \<open>open S\<close> \<open>{a -- b} \<subseteq> S\<close>
     by (force simp: )+
   then obtain d' where d':
     "\<And>x. x \<in> {a--b} \<Longrightarrow> d' x > 0"
     "\<And>x y s. x \<in> {a--b} \<Longrightarrow> (s = 0 \<longrightarrow> y \<noteq> x) \<Longrightarrow> dist (s, y) (0, x) < d' x \<Longrightarrow> flow0 y s \<in> S"
     by (auto simp: eventually_at) metis
   define d2 where "d2 x = d' x / 2" for x
   have d2: "\<And>x. x \<in> {a--b} \<Longrightarrow> d2 x > 0" using d' by (auto simp: d2_def)
   have C: "{a--b} \<subseteq> \<Union>((\<lambda>x. ball x (d2 x)) ` {a -- b})"
     using d2 by auto
   from compactE_image[OF compact_segment _ C]
   obtain C' where "C' \<subseteq> {a--b}" and [simp]: "finite C'"
     and C'_cover: "{a--b} \<subseteq> (\<Union>c\<in>C'. ball c (d2 c))" by auto
 
   define T where "T = Min (insert t (d2 ` C'))"
 
   have "T > 0"
     using \<open>0 < t\<close> d2 \<open>C' \<subseteq> _\<close> 
     by (auto simp: T_def)
   moreover
   note n
   moreover
   have T_ex: "{-T..T} \<subseteq> existence_ivl0 x" if "x \<in> {a--b}" for x
     by (rule order_trans[OF _ t[OF that]]) (auto simp: T_def)
   moreover
   have B_le: "B \<le> f (flow0 x \<xi>) \<bullet> rot n"
     if "x \<in> {a -- b}"
       and c': "c' \<in> C'" "x \<in> ball c' (d2 c')"
       and "\<xi> \<noteq> 0" and \<xi>_le: "\<bar>\<xi>\<bar> < d2 c'"
     for x c' \<xi>
   proof -
     have "c' \<in> {a -- b}" using c' \<open>C' \<subseteq> _\<close> by auto
     moreover have "\<xi> = 0 \<longrightarrow> x \<noteq> c'" using \<open>\<xi> \<noteq> 0\<close> by simp
     moreover have "dist (\<xi>, x) (0, c') < d' c'"
     proof -
       have "dist (\<xi>, x) (0, c') \<le> dist (\<xi>, x) (\<xi>, c') + dist (\<xi>, c') (0, c')"
         by norm
       also have "dist (\<xi>, x) (\<xi>, c') < d2 c'"
         using c'
         by (simp add: dist_prod_def dist_commute)
       also
       have "T \<le> d2 c'" using c'
         by (auto simp: T_def)
       then have "dist (\<xi>, c') (0, c') < d2 c'"
         using \<xi>_le
         by (simp add: dist_prod_def)
       also have "d2 c' + d2 c' = d' c'" by (simp add: d2_def)
       finally show ?thesis by simp
     qed
     ultimately have "flow0 x \<xi> \<in> S"
       by (rule d')
     then show ?thesis
       by (rule S)
   qed
   let ?g = "(\<lambda>x t. (flow0 x t - x) \<bullet> rot n)"
   have cont: "continuous_on {-T .. T} (?g x)"
     if "x \<in> {a--b}" for x
     using T_ex that
     by (force intro!: continuous_intros)
   have deriv: "-T \<le> s' \<Longrightarrow> s' \<le> T \<Longrightarrow> ((?g x) has_derivative
       (\<lambda>t. t * (f (flow0 x s') \<bullet> rot n))) (at s')"
     if "x \<in> {a--b}" for x s'
     using T_ex that
     by (force intro!: derivative_eq_intros simp: flowderiv_def blinfun.bilinear_simps)
 
   have "(flow0 x s - x) \<bullet> rot n > 0" if "x \<in> {a -- b}" "0 < s" "s \<le> T" for x s
   proof (rule ccontr, unfold not_less)
     have [simp]: "x \<in> X" using that \<open>{a -- b} \<subseteq> X\<close> by auto
     assume H: "(flow0 x s - x) \<bullet> rot n \<le> 0"
     have cont: "continuous_on {0 .. s} (?g x)"
       using cont by (rule continuous_on_subset) (use that in auto)
     from mvt[OF \<open>0 < s\<close> cont deriv] that
     obtain \<xi> where \<xi>: "0 < \<xi>" "\<xi> < s" "(flow0 x s - x) \<bullet> rot n = s * (f (flow0 x \<xi>) \<bullet> rot n)"
       by (auto intro: continuous_on_subset)
     note \<open>0 < B\<close>
     also
     from C'_cover that obtain c' where c': "c' \<in> C'" "x \<in> ball c' (d2 c')" by auto
     have "B \<le> f (flow0 x \<xi>) \<bullet> rot n"
     proof (rule B_le[OF that(1) c'])
       show "\<xi> \<noteq> 0" using \<open>0 < \<xi>\<close> by simp
       have "T \<le> d2 c'" using c'
         by (auto simp: T_def)
       then show "\<bar>\<xi>\<bar> < d2 c'"
         using \<open>0 < \<xi>\<close> \<open>\<xi> < s\<close> \<open>s \<le> T\<close>
         by (simp add: dist_prod_def)
     qed
     also from \<xi> H have "\<dots> \<le> 0"
-      by (auto simp add: sign_simps not_less split: if_splits)
-        (metis mult_zero_right real_mult_le_cancel_iff2 that(2))
+      by (auto simp add: algebra_split_simps not_less split: if_splits)
     finally show False by simp
   qed
   moreover
   have "(flow0 x s - x) \<bullet> rot n < 0" if "x \<in> {a -- b}" "-T \<le> s" "s < 0" for x s
   proof (rule ccontr, unfold not_less)
     have [simp]: "x \<in> X" using that \<open>{a -- b} \<subseteq> X\<close> by auto
     assume H: "(flow0 x s - x) \<bullet> rot n \<ge> 0"
     have cont: "continuous_on {s .. 0} (?g x)"
       using cont by (rule continuous_on_subset) (use that in auto)
     from mvt[OF \<open>s < 0\<close> cont deriv] that
     obtain \<xi> where \<xi>: "s < \<xi>" "\<xi> < 0" "(flow0 x s - x) \<bullet> rot n = s * (f (flow0 x \<xi>) \<bullet> rot n)"
       by auto
     note \<open>0 < B\<close>
     also
     from C'_cover that obtain c' where c': "c' \<in> C'" "x \<in> ball c' (d2 c')" by auto
     have "B \<le> (f (flow0 x \<xi>) \<bullet> rot n)"
     proof (rule B_le[OF that(1) c'])
       show "\<xi> \<noteq> 0" using \<open>0 > \<xi>\<close> by simp
       have "T \<le> d2 c'" using c'
         by (auto simp: T_def)
       then show "\<bar>\<xi>\<bar> < d2 c'"
         using \<open>0 > \<xi>\<close> \<open>\<xi> > s\<close> \<open>s \<ge> - T\<close>
         by (simp add: dist_prod_def)
     qed
     also from \<xi> H have "\<dots> \<le> 0"
-      by (simp add: sign_simps algebra_simps)
-        (metis less_eq_real_def mult_less_cancel_left mult_pos_neg2 mult_zero_right that(3))
+      by (simp add: algebra_split_simps)
     finally show False by simp
   qed
   ultimately show ?thesis ..
 qed
 
 
 lemma inner_rot_pos_move_base: "(x - a) \<bullet> rot (a - b) > 0"
   if "(x - y) \<bullet> rot (a - b) > 0" "y \<in> {a -- b}"
   by (smt in_segment_inner_rot inner_diff_left inner_minus_right minus_diff_eq rot_rot that)
 
 lemma inner_rot_neg_move_base: "(x - a) \<bullet> rot (a - b) < 0"
   if "(x - y) \<bullet> rot (a - b) < 0" "y \<in> {a -- b}"
   by (smt in_segment_inner_rot inner_diff_left inner_minus_right minus_diff_eq rot_rot that)
 
 lemma inner_pos_move_base: "(x - a) \<bullet> n > 0"
   if "(a - b) \<bullet> n = 0" "(x - y) \<bullet> n > 0" "y \<in> {a -- b}"
 proof -
   from that(3) obtain u where y_def: "y = (1 - u) *\<^sub>R a + u *\<^sub>R b" and u: "0 \<le> u" "u \<le> 1"
     by (auto simp: in_segment)
   have "(x - a) \<bullet> n = (x - y) \<bullet> n - u * ((a - b) \<bullet> n)"
     by (simp add: algebra_simps y_def)
   also have "\<dots> = (x - y) \<bullet> n"
     by (simp add: that)
   also note \<open>\<dots> > 0\<close>
   finally show ?thesis .
 qed
 
 lemma inner_neg_move_base: "(x - a) \<bullet> n < 0"
   if "(a - b) \<bullet> n = 0" "(x - y) \<bullet> n < 0" "y \<in> {a -- b}"
 proof -
   from that(3) obtain u where y_def: "y = (1 - u) *\<^sub>R a + u *\<^sub>R b" and u: "0 \<le> u" "u \<le> 1"
     by (auto simp: in_segment)
   have "(x - a) \<bullet> n = (x - y) \<bullet> n - u * ((a - b) \<bullet> n)"
     by (simp add: algebra_simps y_def)
   also have "\<dots> = (x - y) \<bullet> n"
     by (simp add: that)
   also note \<open>\<dots> < 0\<close>
   finally show ?thesis .
 qed
 
 lemma rot_same_dir:
   assumes "x1 \<in> {a<--<b}"
   assumes "x2 \<in> {x1<--<b}"
   shows "(y \<bullet> rot (a-b) > 0) = (y \<bullet> rot(x1-x2) > 0)"  "(y \<bullet> rot (a-b) < 0) = (y \<bullet> rot(x1-x2) < 0)"
   using oriented_subsegment_scale[OF assms]
    apply (smt inner_scaleR_right nrm_reverse rot_scaleR zero_less_mult_iff)
   by (smt \<open>\<And>thesis. (\<And>e. \<lbrakk>0 < e; b - a = e *\<^sub>R (x2 - x1)\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis\<close> inner_minus_right inner_scaleR_right rot_diff_commute rot_scaleR zero_less_mult_iff)
 
 
 subsection \<open>Monotone Step Lemma\<close>
 
 lemma flow0_transversal_segment_monotone_step:
   assumes "transversal_segment a b"
   assumes "t1 \<le> t2" "{t1..t2} \<subseteq> existence_ivl0 x"
   assumes x1: "flow0 x t1 \<in> {a<--<b}"
   assumes x2: "flow0 x t2 \<in> {flow0 x t1<--<b}"
   assumes "\<And>t. t \<in> {t1<..<t2} \<Longrightarrow> flow0 x t \<notin> {a<--<b}"
   assumes "t > t2" "t \<in> existence_ivl0 x"
   shows "flow0 x t \<notin> {a<--<flow0 x t2}"
 proof -
   note exist = \<open>{t1..t2} \<subseteq> existence_ivl0 x\<close>
   note t1t2 = \<open>\<And>t. t \<in> {t1<..<t2} \<Longrightarrow> flow0 x t \<notin> {a<--<b}\<close>
     (* Basic properties of the segment *)
   have x1neqx2: "flow0 x t1 \<noteq> flow0 x t2"
     using open_segment_def x2 by force 
   then have t1neqt2: "t1 \<noteq> t2" by auto
 
   have [simp]: "a \<noteq> b" and \<open>{a -- b} \<subseteq> X\<close> using \<open>transversal_segment a b\<close>
     by (auto simp: transversal_segment_def)
 
   from x1 obtain i1 where i1: "flow0 x t1 = line a b i1" "0 < i1" "i1 < 1"
     by (auto simp: in_open_segment_iff_line)
   from x2 obtain i2 where i2: "flow0 x t2 = line a b i2" "0 < i1" "i1 < i2"
     by (auto simp: i1 line_open_segment_iff)
 
 
   have "{a <--< flow0 x t1} \<subseteq> {a<--<b}"
     by (simp add: open_closed_segment subset_open_segment x1) 
   have t12sub: "{flow0 x t1--flow0 x t2} \<subseteq> {a<--<b}"
     by (metis ends_in_segment(2) open_closed_segment subset_co_segment subset_eq subset_open_segment x1 x2)
   have subr: "{flow0 x t1<--<flow0 x t2} \<subseteq> {flow0 x t1 <--<b}"
     by (simp add: open_closed_segment subset_open_segment x2)
   have "flow0 x t1 \<in> {a <--<flow0 x t2}" using x1 x2
     by (rule open_segment_subsegment)
   then have subl: "{flow0 x t1<--<flow0 x t2} \<subseteq> {a <--< flow0 x t2}" using x1 x2
     by (simp add: open_closed_segment subset_open_segment x2)
   then have subl2: "{flow0 x t1--<flow0 x t2} \<subseteq> {a <--< flow0 x t2}" using x1 x2
     by (smt DiffE DiffI \<open>flow0 x t1 \<in> {a<--<flow0 x t2}\<close> half_open_segment_def insert_iff open_segment_def subset_eq)
 
   have sub1b: "{flow0 x t1--b} \<subseteq> {a--b}"
     by (simp add: open_closed_segment subset_closed_segment x1)
   have suba2: "{a--flow0 x t2} \<subseteq> {a -- b}"
     using open_closed_segment subset_closed_segment t12sub by blast
   then have suba2o: "{a<--<flow0 x t2} \<subseteq> {a -- b}"
     using open_closed_segment subset_closed_segment t12sub by blast
   have x2_notmem: "flow0 x t2 \<notin> {a--flow0 x t1}"
     using i1 i2
     by (auto simp: closed_segment_line_iff)
   have suba12: "{a--flow0 x t1} \<subseteq> {a--flow0 x t2}"
     by (simp add: \<open>flow0 x t1 \<in> {a<--<flow0 x t2}\<close> open_closed_segment subset_closed_segment)
   then have suba12_open: "{a<--<flow0 x t1} \<subseteq> {a<--<flow0 x t2}"
     using x2_notmem
     by (auto simp: open_segment_def)
   have "flow0 x t2 \<in> {a--b}"
     using suba2 by auto
 
   have intereq: "\<And>t. t1 \<le> t \<Longrightarrow> t \<le> t2 \<Longrightarrow> flow0 x t \<in> {a<--<b} \<Longrightarrow>  t = t1 \<or> t = t2"
   proof (rule ccontr)
     fix t
     assume t: "t1 \<le> t" "t \<le> t2" "flow0 x t \<in> {a<--<b}" "\<not>(t= t1 \<or> t = t2)"
     then have "t \<in> {t1<..<t2}" by auto
     then have "flow0 x t \<notin> {a<--<b}" using t1t2 by blast
     thus False using t by auto
   qed
   then have intereqt12: "\<And>t. t1 \<le> t \<Longrightarrow> t \<le> t2 \<Longrightarrow> flow0 x t \<in> {flow0 x t1--flow0 x t2} \<Longrightarrow>  t = t1 \<or> t = t2"
     using t12sub by blast
 
 (* The Jordan curve *)
   define J1 where "J1 = flow_to_path x t1 t2"
   define J2 where "J2 = linepath (flow0 x t2) (flow0 x t1)" 
   define J where "J = J1 +++ J2"
     (* Proof that J is a Jordan curve *)
   have "pathfinish J = pathstart J" unfolding J_def J1_def J2_def
     by (auto simp add: pathstart_compose pathfinish_compose)
   have piJ: "path_image J = path_image J1 \<union> path_image J2"
     unfolding J_def J1_def J2_def
     apply (rule path_image_join)
     by auto
   have "flow0 x t1 \<in> flow0 x ` {t1..t2} \<and> flow0 x t2 \<in> flow0 x ` {t1..t2}"
     using atLeastAtMost_iff \<open>t1 \<le> t2\<close> by blast 
   then have piD: "path_image J = path_image J1 \<union> {flow0 x t1 <--<flow0 x t2}"
     unfolding piJ J1_def J2_def path_image_flow_to_path[OF \<open>t1 \<le> t2\<close>]
       path_image_linepath open_segment_def
     by (smt Diff_idemp Diff_insert2 Un_Diff_cancel closed_segment_commute mk_disjoint_insert)
   have "\<forall>s\<in>{t1<..<t2}. flow0 x s \<noteq> flow0 x t1"
     using x1 t1t2 by fastforce
   from flow_to_path_arc[OF \<open>t1 \<le> t2\<close> exist this x1neqx2]
   have "arc J1" using J1_def assms flow_to_path_arc by auto
   then have "simple_path J" unfolding J_def
     using \<open>arc J1\<close> J1_def J2_def assms x1neqx2 t1neqt2 apply (auto intro!:simple_path_join_loop)
     using intereqt12 closed_segment_commute by blast
 
   from Jordan_inside_outside_R2[OF this \<open>pathfinish J = pathstart J\<close>]
   obtain inner outer where inner_def: "inner = inside (path_image J)"
     and outer_def: "outer = outside (path_image J)"
     and io:
     "inner \<noteq> {}" "open inner" "connected inner"
     "outer \<noteq> {}" "open outer" "connected outer"
     "bounded inner" "\<not> bounded outer" "inner \<inter> outer = {}"
     "inner \<union> outer = - path_image J"
     "frontier inner = path_image J"
     "frontier outer = path_image J" by metis
   from io have io2: "outer \<inter> inner = {}" "outer \<union> inner = - path_image J" by auto
 
   have swap_side: "\<And>y t. y \<in> side2 \<Longrightarrow>
     0 \<le> t \<Longrightarrow> t \<in> existence_ivl0 y \<Longrightarrow>
     flow0 y t \<in> closure side1 \<Longrightarrow>
     \<exists>T. 0 < T \<and> T \<le> t \<and> (\<forall>s \<in>{0..<T}. flow0 y s \<in> side2) \<and>
         flow0 y T \<in> {flow0 x t1--<flow0 x t2}"
     if "side1 \<inter> side2 = {}"
       "open side2"
       "frontier side1 = path_image J"
       "frontier side2 = path_image J"
       "side1 \<union> side2 = - path_image J"
     for side1 side2
   proof -
     fix y t
     assume yt: "y \<in> side2" "0 \<le> t" "t \<in> existence_ivl0 y"
       "flow0 y t \<in> closure side1"
     define fp where "fp = flow_to_path y 0 t"
     have ex:"{0..t} \<subseteq> existence_ivl0 y"
       using ivl_subset_existence_ivl yt(3) by blast
     then have y0:"flow0 y 0 = y"
       using mem_existence_ivl_iv_defined(2) yt(3) by auto
     then have tpos: "t > 0" using yt(2)  \<open>side1 \<inter> side2 = {}\<close>
       using yt(1) yt(4)
       by (metis closure_iff_nhds_not_empty less_eq_real_def order_refl that(2)) 
     from flow_to_path_path[OF yt(2) ex]
     have a1: "path fp" unfolding fp_def .
     have "y \<in> closure side2" using yt(1)
       by (simp add: assms closure_def)
     then have a2: "pathstart fp \<in> closure side2" unfolding fp_def using y0 by auto
     have a3:"pathfinish fp \<notin> side2" using yt(4) \<open>side1 \<inter> side2 = {}\<close>
       unfolding fp_def apply auto
       using closure_iff_nhds_not_empty that(2) by blast
     from subpath_to_frontier_strong[OF a1 a3]
     obtain u where u:"0 \<le> u" "u \<le> 1"
       "fp u \<notin> interior side2"
       "u = 0 \<or>
       (\<forall>x. 0 \<le> x \<and> x < 1 \<longrightarrow>
         subpath 0 u fp x \<in> interior side2) \<and> fp u \<in> closure side2" by blast
     have p1:"path_image (subpath 0 u fp) =  flow0 y ` {0 ..  u*t}"
       unfolding fp_def subpath0_flow_to_path using path_image_flow_to_path
       by (simp add: u(1) yt(2))
     have p2:"fp u = flow0 y (u*t)" unfolding fp_def flow_to_path_unfold by simp
     have inout:"interior side2 = side2" using \<open>open side2\<close>
       by (simp add: interior_eq)
     then have iemp: "side2 \<inter> path_image J = {}"
       using \<open>frontier side2 = path_image J\<close>
       by (metis frontier_disjoint_eq inf_sup_aci(1) interior_eq)
     have "u \<noteq> 0" using inout u(3) y0 p2 yt(1) by force
     then have c1:"u * t > 0" using tpos u y0  \<open>side1 \<inter> side2 = {}\<close>
       using frontier_disjoint_eq io(5) yt(1) zero_less_mult_iff by fastforce
     have uim:"fp u \<in> path_image J" using u \<open>u \<noteq> 0\<close>
       using \<open>frontier side2 = path_image J\<close>
       by (metis ComplI IntI closure_subset frontier_closures inout subsetD) 
     have c2:"u * t \<le> t"  using u(1-2) tpos by auto
     have"(flow_to_path y 0 (u * t) ` {0..<1} \<subseteq> side2)"
       using \<open>u \<noteq> 0\<close> u inout unfolding fp_def subpath0_flow_to_path by auto
     then have c3:"\<forall>s \<in>{0..<u*t}. flow0 y s \<in> side2" by auto
     have c4: "flow0 y (u*t) \<in> path_image J"
       using uim path_image_join_subset
       by (simp add: p2)
     have "flow0 y (u*t) \<notin> path_image J1 \<or> flow0 y (u*t) = flow0 x t1"
     proof clarsimp
       assume "flow0 y (u*t) \<in> path_image J1"
       then obtain s where s: "t1 \<le> s" "s \<le> t2" "flow0 x s = flow0 y (u*t)"
         using J1_def \<open>t1 \<le> t2\<close> by auto
       have "s = t1"
       proof (rule ccontr)
         assume "s \<noteq> t1"
         then have st1:"s > t1" using s(1) by linarith
         define sc where "sc = min (s-t1) (u*t)"
         have scd: "s-sc \<in> {t1..t2}" unfolding sc_def
           using c1 s(1) s(2) by auto
         then have *:"flow0 x (s-sc) \<in> path_image J1" unfolding J1_def path_image_flow_to_path[OF \<open>t1 \<le> t2\<close>]
           by blast
         have "flow0 x (s-sc) = flow0 (flow0 x s) (-sc)"
           by (smt exist atLeastAtMost_iff existence_ivl_trans' flow_trans s(1) s(2) scd subsetD)
         then have **:"flow0 (flow0 y (u*t)) (-sc)  \<in> path_image J1"
           using s(3) * by auto
         have b:"u*t - sc \<in> {0..<u*t}" unfolding sc_def by (simp add: st1 c1 s(1))
         then have "u*t - sc \<in> existence_ivl0 y"
           using c2 ex by auto 
         then have "flow0 y (u*t - sc) \<in> path_image J1" using **
           by (smt atLeastAtMost_iff diff_existence_ivl_trans ex flow_trans mult_left_le_one_le mult_nonneg_nonneg subset_eq u(1) u(2) yt(2))
         thus False using b c3 iemp piJ by blast
       qed
       thus "flow0 y (u * t) = flow0 x t1" using s by simp
     qed
     thus "\<exists>T>0. T \<le> t \<and> (\<forall>s\<in>{0..<T}. flow0 y s \<in> side2) \<and>
           flow0 y T \<in> {flow0 x t1--<flow0 x t2}"
       using c1 c2 c3 c4 unfolding piD
       by (metis DiffE UnE ends_in_segment(1) half_open_segment_closed_segmentI insertCI open_segment_def x1neqx2)
   qed
   have outside_in: "\<And>y t. y \<in> outer \<Longrightarrow>
     0 \<le> t \<Longrightarrow> t \<in> existence_ivl0 y \<Longrightarrow>
     flow0 y t \<in> closure inner \<Longrightarrow>
     \<exists>T. 0 < T \<and> T \<le> t \<and> (\<forall>s \<in>{0..<T}. flow0 y s \<in> outer) \<and>
           flow0 y T \<in> {flow0 x t1--<flow0 x t2}"
     by (rule swap_side; (rule io | assumption))
   have inside_out: "\<And>y t. y \<in> inner \<Longrightarrow>
     0 \<le> t \<Longrightarrow> t \<in> existence_ivl0 y \<Longrightarrow>
     flow0 y t \<in> closure outer \<Longrightarrow>
     \<exists>T. 0 < T \<and> T \<le> t \<and> (\<forall>s \<in>{0..<T}. flow0 y s \<in> inner) \<and>
           flow0 y T \<in> {flow0 x t1--<flow0 x t2}"
     by (rule swap_side; (rule io2 io | assumption))
 
   from leaves_transversal_segmentE[OF assms(1)]
   obtain d n where d: "d > (0::real)"
     and n: "n = a - b \<or> n = b - a"
     and d_ex: "\<And>x. x \<in> {a -- b} \<Longrightarrow> {-d..d} \<subseteq> existence_ivl0 x"
     and d_above: "\<And>x s. x \<in> {a -- b} \<Longrightarrow> 0 < s \<Longrightarrow> s \<le> d \<Longrightarrow> (flow0 x s - x) \<bullet> rot n > 0"
     and d_below: "\<And>x s. x \<in> {a -- b} \<Longrightarrow> -d \<le> s \<Longrightarrow> s < 0 \<Longrightarrow> (flow0 x s - x) \<bullet> rot n < 0"
     by blast
 
   have ortho: "(a - b) \<bullet> rot n = 0"
     using n by (auto simp: algebra_simps)
 
 (* These "rectangles" are either fully inside or fully outside
            |-----------------------|
            |           r1          | (flow d)
     a --- (t1) --- rp --- (t2) --- b
     |          r2           | (flow -d)
     |-----------------------|
    *)
   define r1 where "r1 = (\<lambda>(x, y). flow0 x y)`({flow0 x t1<--<b} \<times> {0<..<d}) "
   have r1a1: "path_connected {flow0 x t1 <--<b}" by simp
   have r1a2: "path_connected {0<..<d}" by simp
   have "{flow0 x t1<--<b} \<subseteq> {a--b}"
     by (simp add: open_closed_segment subset_oc_segment x1)
   then have r1a3: "y \<in> {flow0 x t1<--<b} \<Longrightarrow> {0<..<d} \<subseteq> existence_ivl0 y" for y
     using d_ex[of y]
     by force
   from flow0_path_connected[OF r1a1 r1a2 r1a3]
   have pcr1:"path_connected r1" unfolding r1_def by auto
   have pir1J1: "r1 \<inter> path_image J1 = {}"
     unfolding J1_def path_image_flow_to_path[OF \<open>t1 \<le> t2\<close>]
   proof (rule ccontr)
     assume "r1 \<inter> flow0 x ` {t1..t2} \<noteq> {}"
     then obtain xx tt ss where
       eq: "flow0 xx tt = flow0 x ss"
       and xx: "xx \<in> {flow0 x t1<--<b}"
       and ss: "t1 \<le> ss" "ss \<le> t2"
       and tt: "0 < tt" "tt < d"
       unfolding r1_def
       by force
     have "xx \<in> {a -- b}"
       using sub1b
       apply (rule set_mp)
       using xx by (simp add: open_closed_segment)
     then have [simp]: "xx \<in> X" using \<open>transversal_segment a b\<close> by (auto simp: transversal_segment_def)
     from ss have ss_ex: "ss \<in> existence_ivl0 x" using exist
       by auto
     from d_ex[OF \<open>xx \<in> {a -- b}\<close>] tt
     have tt_ex: "tt \<in> existence_ivl0 xx" by auto
     then have neg_tt_ex: "- tt \<in> existence_ivl0 (flow0 xx tt)"
       by (rule existence_ivl_reverse[simplified])
     from eq have "flow0 (flow0 xx tt) (-tt) = flow0 (flow0 x ss) (-tt)"
       by simp
     then have "xx = flow0 x (ss - tt)"
       apply (subst (asm) flow_trans[symmetric])
         apply (rule tt_ex)
        apply (rule neg_tt_ex)
       apply (subst (asm) flow_trans[symmetric])
         apply (rule ss_ex)
        apply (subst eq[symmetric])
        apply (rule neg_tt_ex)
       by simp
     moreover
     define e where "e = ss - t1"
     consider "e > tt" | "e \<le> tt" by arith
     then show False
     proof cases
       case 1
       have "flow0 (flow0 x ss) (-tt) \<notin> {a<--<b}"
         apply (subst flow_trans[symmetric])
           apply fact
         subgoal using neg_tt_ex eq by simp
         apply (rule t1t2)
         using 1 ss tt
         unfolding e_def
         by auto
       moreover have "flow0 (flow0 x ss) (-tt) \<in> {a<--<b}"
         unfolding eq[symmetric] using tt_ex xx
         apply (subst flow_trans[symmetric])
           apply (auto simp add: neg_tt_ex)
         by (metis (no_types, hide_lams) sub1b subset_eq subset_open_segment)
       ultimately show ?thesis by simp
     next
       case 2
       have les: "0 \<le> tt - e" "tt - e \<le> d"
         using tt ss 2 e_def
         by auto
       have xxtte: "flow0 xx (tt - e) = flow0 x t1"
         apply (simp add: e_def)
         by (smt \<open>0 \<le> tt - e\<close> \<open>{- d..d} \<subseteq> existence_ivl0 xx\<close> atLeastAtMost_iff e_def eq
             local.existence_ivl_reverse local.existence_ivl_trans local.flow_trans ss(1) ss_ex subset_iff tt(2))
       show False
       proof (cases "tt = e")
         case True
         with xxtte have "xx = flow0 x t1"
           by (simp add: )
         with xx show ?thesis
           apply auto
           by (auto simp: open_segment_def)
       next
         case False
         with les have "0 < tt - e" by (simp)
         from d_above[OF \<open>xx \<in> {a -- b}\<close> this \<open>tt - e \<le> d\<close>]
         have "flow0 xx (tt - e) \<notin> {a -- b}"
           apply (simp add: in_closed_segment_iff_rot[OF \<open>a \<noteq> b\<close>]
               not_le )
           by (smt \<open>xx \<in> {a--b}\<close> inner_minus_right inner_rot_neg_move_base inner_rot_pos_move_base n rot_diff_commute)
         with xxtte show ?thesis
           using \<open>flow0 x t1 \<in> {a<--<flow0 x t2}\<close> suba2o by auto
       qed
     qed
   qed
     (* for sufficiently small d, the flow does not return to the line *)
   moreover
   have pir1J2: "r1 \<inter> path_image J2 = {}"
   proof -
     have "r1 \<subseteq> {x. (x - a) \<bullet> rot n > 0}"
       unfolding r1_def
     proof safe
       fix aa ba
       assume "aa \<in> {flow0 x t1<--<b}" "ba \<in> {0<..<d}"
       with sub1b show "0 < (flow0 aa ba - a) \<bullet> rot n"
         using segment_open_subset_closed[of "flow0 x t1" b]
         by (intro inner_pos_move_base[OF ortho d_above]) auto
     qed
     also have "\<dots> \<inter> {a -- b} = {}"
       using in_segment_inner_rot in_segment_inner_rot2 n by auto
     finally show ?thesis
       unfolding J2_def path_image_linepath
       using t12sub open_closed_segment
       by (force simp: closed_segment_commute)
   qed
   ultimately have pir1:"r1 \<inter> (path_image J) = {}" unfolding J_def
     by (metis disjoint_iff_not_equal not_in_path_image_join)
 
   define r2 where "r2 =(\<lambda>(x, y). flow0 x y)`({a <--< flow0 x t2} \<times> {-d<..<0})"
   have r2a1:"path_connected {a <--< flow0 x t2}" by simp
   have r2a2:"path_connected {-d<..<0}" by simp
   have "{a <--< flow0 x t2} \<subseteq> {a -- b}"
     by (meson ends_in_segment(1) open_closed_segment subset_co_segment subset_oc_segment t12sub)
   then have r2a3: "y \<in> {a <--< flow0 x t2} \<Longrightarrow> {-d<..<0} \<subseteq> existence_ivl0 y" for y
     using d_ex[of y]
     by force
   from flow0_path_connected[OF r2a1 r2a2 r2a3]
   have pcr2:"path_connected r2" unfolding r2_def by auto
   have pir2J2: "r2 \<inter> path_image J1 = {}"
     unfolding J1_def path_image_flow_to_path[OF \<open>t1 \<le> t2\<close>]
   proof (rule ccontr)
     assume "r2 \<inter> flow0 x ` {t1..t2} \<noteq> {}"
     then obtain xx tt ss where
       eq: "flow0 xx tt = flow0 x ss"
       and xx: "xx \<in> {a<--<flow0 x t2}"
       and ss: "t1 \<le> ss" "ss \<le> t2"
       and tt: "-d < tt" "tt < 0"
       unfolding r2_def
       by force
     have "xx \<in> {a -- b}"
       using suba2
       apply (rule set_mp)
       using xx by (simp add: open_closed_segment)
     then have [simp]: "xx \<in> X" using \<open>transversal_segment a b\<close> by (auto simp: transversal_segment_def)
     from ss have ss_ex: "ss \<in> existence_ivl0 x" using exist
       by auto
     from d_ex[OF \<open>xx \<in> {a -- b}\<close>] tt
     have tt_ex: "tt \<in> existence_ivl0 xx" by auto
     then have neg_tt_ex: "- tt \<in> existence_ivl0 (flow0 xx tt)"
       by (rule existence_ivl_reverse[simplified])
     from eq have "flow0 (flow0 xx tt) (-tt) = flow0 (flow0 x ss) (-tt)"
       by simp
     then have "xx = flow0 x (ss - tt)"
       apply (subst (asm) flow_trans[symmetric])
         apply (rule tt_ex)
        apply (rule neg_tt_ex)
       apply (subst (asm) flow_trans[symmetric])
         apply (rule ss_ex)
        apply (subst eq[symmetric])
        apply (rule neg_tt_ex)
       by simp
     moreover
     define e where "e = t2 - ss"
     consider "e > - tt" | "e \<le> -tt" by arith
     then show False
     proof cases
       case 1
       have "flow0 (flow0 x ss) (-tt) \<notin> {a<--<b}"
         apply (subst flow_trans[symmetric])
           apply fact
         subgoal using neg_tt_ex eq by simp
         apply (rule t1t2)
         using 1 ss tt
         unfolding e_def
         by auto
       moreover have "flow0 (flow0 x ss) (-tt) \<in> {a<--<b}"
         unfolding eq[symmetric] using tt_ex xx
         apply (subst flow_trans[symmetric])
           apply (auto simp add: neg_tt_ex)
         by (metis (no_types, hide_lams) suba2 subset_eq subset_open_segment)
       ultimately show ?thesis by simp
     next
       case 2
       have les: "tt + e \<le> 0" "-d \<le> tt + e"
         using tt ss 2 e_def
         by auto
       have xxtte: "flow0 xx (tt + e) = flow0 x t2"
         apply (simp add: e_def)
         by (smt atLeastAtMost_iff calculation eq exist local.existence_ivl_trans' local.flow_trans neg_tt_ex ss_ex subset_iff \<open>t1 \<le> t2\<close>)
       show False
       proof (cases "tt=-e")
         case True
         with xxtte have "xx = flow0 x t2"
           by (simp add: )
         with xx show ?thesis
           apply auto
           by (auto simp: open_segment_def)
       next
         case False
         with les have "tt+e < 0" by simp
         from d_below[OF \<open>xx \<in> {a -- b}\<close>  \<open>-d \<le> tt + e\<close> this]
         have "flow0 xx (tt + e) \<notin> {a -- b}"
           apply (simp add: in_closed_segment_iff_rot[OF \<open>a \<noteq> b\<close>]
               not_le )
           by (smt \<open>xx \<in> {a--b}\<close> inner_minus_right inner_rot_neg_move_base inner_rot_pos_move_base n rot_diff_commute)
         with xxtte show ?thesis
           using \<open>flow0 x t2 \<in> {a--b}\<close> by simp
       qed
     qed
   qed
   moreover
   have pir2J2: "r2 \<inter> path_image J2 = {}"
   proof -
     have "r2 \<subseteq> {x. (x - a) \<bullet> rot n < 0}"
       unfolding r2_def
     proof safe
       fix aa ba
       assume "aa \<in> {a<--<flow0 x t2}" "ba \<in> {-d<..<0}"
       with suba2 show "0 > (flow0 aa ba - a) \<bullet> rot n"
         using segment_open_subset_closed[of a "flow0 x t2"]
         by (intro inner_neg_move_base[OF ortho d_below]) auto
     qed
     also have "\<dots> \<inter> {a -- b} = {}"
       using in_segment_inner_rot in_segment_inner_rot2 n by auto
     finally show ?thesis
       unfolding J2_def path_image_linepath
       using t12sub open_closed_segment
       by (force simp: closed_segment_commute)
   qed
   ultimately have pir2:"r2 \<inter> (path_image J) = {}"
     unfolding J_def
     by (metis disjoint_iff_not_equal not_in_path_image_join)
 
   define rp where "rp = midpoint (flow0 x t1) (flow0 x t2)"
   have rpi: "rp \<in> {flow0 x t1<--<flow0 x t2}" unfolding rp_def
     by (simp add: x1neqx2)
   have "rp \<in> {a -- b}"
     using rpi suba2o subl by blast
   then have [simp]: "rp \<in> X"
     using \<open>{a--b} \<subseteq> X\<close> by blast
 
 (* The fundamental case distinction *)
   have *: "pathfinish J1 = flow0 x t2"
     "pathstart J1 = flow0 x t1"
     "rp \<in> {flow0 x t2<--<flow0 x t1}"
     using rpi
     by (auto simp: open_segment_commute J1_def)
   have "{y. 0 < (y - flow0 x t2) \<bullet> rot (flow0 x t2 - flow0 x t1)} = {y. 0 < (y - rp) \<bullet> rot (flow0 x t2 - flow0 x t1)}"
     by (smt Collect_cong in_open_segment_rotD inner_diff_left nrm_dot rpi)
   also have "... =  {y. 0 > (y - rp) \<bullet> rot (flow0 x t1 - flow0 x t2)}"
     by (smt Collect_cong inner_minus_left nrm_reverse)
   also have " ... = {y. 0 > (y - rp) \<bullet> rot (a - b) }"
     by (metis rot_same_dir(2) x1 x2)
   finally have side1: "{y. 0 < (y - flow0 x t2) \<bullet> rot (flow0 x t2 - flow0 x t1)} = {y. 0 > (y - rp) \<bullet> rot (a - b) }"
     (is "_ = ?lower1") .
   have "{y. (y - flow0 x t2) \<bullet> rot (flow0 x t2 - flow0 x t1) < 0} = {y. (y - rp) \<bullet> rot (flow0 x t2 - flow0 x t1) < 0}"
     by (smt Collect_cong in_open_segment_rotD inner_diff_left nrm_dot rpi)
   also have "... =  {y. (y - rp) \<bullet> rot (flow0 x t1 - flow0 x t2) > 0}"
     by (smt Collect_cong inner_minus_left nrm_reverse)
   also have " ... = {y. 0 < (y - rp) \<bullet> rot (a - b) }"
     by (metis rot_same_dir(1) x1 x2)
   finally have side2: "{y. (y - flow0 x t2) \<bullet> rot (flow0 x t2 - flow0 x t1) < 0} = {y. 0 < (y - rp) \<bullet> rot (a - b) }"
     (is "_ = ?upper1") .
   from linepath_ball_inside_outside[OF \<open>simple_path J\<close>[unfolded J_def J2_def] *,
       folded J2_def J_def, unfolded side1 side2]
   obtain e where e0: "0 < e"
     "ball rp e \<inter> path_image J1 = {}"
     "ball rp e \<inter> ?lower1 \<subseteq> inner \<and>
         ball rp e \<inter> ?upper1 \<subseteq> outer \<or>
         ball rp e \<inter> ?upper1 \<subseteq> inner \<and>
         ball rp e \<inter> ?lower1 \<subseteq> outer"
     by (auto simp: inner_def outer_def)
 
   let ?lower = "{y. 0 > (y - rp) \<bullet> rot n }"
   let ?upper = "{y. 0 < (y - rp) \<bullet> rot n }"
   have "?lower1 = {y. 0 < (y - rp) \<bullet> rot n } \<and> ?upper1 = {y. 0 > (y - rp) \<bullet> rot n } \<or>
       ?lower1 = {y. 0 > (y - rp) \<bullet> rot n } \<and> ?upper1 =  {y. 0 < (y - rp) \<bullet> rot n }"
     using n rot_diff_commute[of a b]
     by auto
   from this e0 have e: "0 < e"
     "ball rp e \<inter> path_image J1 = {}"
     "ball rp e \<inter> ?lower \<subseteq> inner \<and>
         ball rp e \<inter> ?upper \<subseteq> outer \<or>
         ball rp e \<inter> ?upper \<subseteq> inner \<and>
         ball rp e \<inter> ?lower \<subseteq> outer"
     by auto
 
   have "\<forall>\<^sub>F t in at_right 0. t < d"
     by (auto intro!: order_tendstoD \<open>0 < d\<close>)
   then have evr: "\<forall>\<^sub>F t in at_right 0. 0 < (flow0 rp t - rp) \<bullet> rot n"
     unfolding eventually_at_filter
     by eventually_elim (auto intro!: \<open>rp \<in> {a--b}\<close> d_above)
   have "\<forall>\<^sub>F t in at_left 0. t > -d"
     by (auto intro!: order_tendstoD \<open>0 < d\<close>)
   then have evl: "\<forall>\<^sub>F t in at_left 0. 0 > (flow0 rp t - rp) \<bullet> rot n"
     unfolding eventually_at_filter
     by eventually_elim (auto intro!: \<open>rp \<in> {a--b}\<close> d_below)
   have "\<forall>\<^sub>F t in at 0. flow0 rp t \<in> ball rp e"
     unfolding mem_ball
     apply (subst dist_commute)
     apply (rule tendstoD)
     by (auto intro!: tendsto_eq_intros \<open>0 < e\<close>)
   then have evl2: "(\<forall>\<^sub>F t in at_left 0. flow0 rp t \<in> ball rp e)"
     and evr2: "(\<forall>\<^sub>F t in at_right 0. flow0 rp t \<in> ball rp e)"
     unfolding eventually_at_split by auto
   have evl3: "(\<forall>\<^sub>F t in at_left 0. t > -d)"
     and evr3: "(\<forall>\<^sub>F t in at_right 0. t < d)"
     by (auto intro!: order_tendstoD \<open>0 < d\<close>)
   have evl4: "(\<forall>\<^sub>F t in at_left 0. t < 0)"
     and evr4: "(\<forall>\<^sub>F t in at_right 0. t > 0)"
     by (auto simp: eventually_at_filter)
   from evl evl2 evl3 evl4
   have "\<forall>\<^sub>F t in at_left 0. (flow0 rp t - rp) \<bullet> rot n < 0 \<and> flow0 rp t \<in> ball rp e \<and> t > -d \<and> t < 0"
     by eventually_elim auto
   from eventually_happens[OF this]
   obtain dl where dl: "(flow0 rp dl - rp) \<bullet> rot n < 0" "flow0 rp dl \<in> ball rp e" "- d < dl" "dl < 0"
     by auto
   from evr evr2 evr3 evr4
   have "\<forall>\<^sub>F t in at_right 0. (flow0 rp t - rp) \<bullet> rot n > 0 \<and> flow0 rp t \<in> ball rp e \<and> t < d \<and> t > 0"
     by eventually_elim auto
   from eventually_happens[OF this]
   obtain dr where dr: "(flow0 rp dr - rp) \<bullet> rot n > 0" "flow0 rp dr \<in> ball rp e" "d > dr" "dr > 0"
     by auto
 
   have "rp \<in> {flow0 x t1<--<b}" using rpi subr by auto
   then have rpr1:"flow0 rp (dr) \<in> r1" unfolding r1_def using \<open>d > dr\<close> \<open>dr > 0\<close>
     by auto
   have "rp \<in> {a<--<flow0 x t2}" using rpi subl by auto
   then have rpr2:"flow0 rp (dl) \<in> r2" unfolding r2_def using \<open>-d < dl\<close> \<open>dl < 0\<close>
     by auto
 
   from e(3) dr dl
   have "flow0 rp (dr) \<in> outer \<and> flow0 rp (dl) \<in> inner \<or> flow0 rp (dr) \<in> inner \<and> flow0 rp (dl) \<in> outer"
     by auto
   moreover {
     assume "flow0 rp dr \<in> outer" "flow0 rp dl \<in> inner"
     then have
       r1o: "r1 \<inter> outer \<noteq> {}" and
       r2i: "r2 \<inter> inner \<noteq> {}" using rpr1 rpr2 by auto
     from path_connected_not_frontier_subset[OF pcr1 r1o]
     have "r1 \<subseteq> outer" using pir1 by (simp add: io(12))
     from path_connected_not_frontier_subset[OF pcr2 r2i]
     have "r2 \<subseteq> inner" using pir2 by (simp add: io(11))
     have "(\<lambda>(x, y). flow0 x y)`({flow0 x t2} \<times> {0<..<d}) \<subseteq> r1" unfolding r1_def
       by (auto intro!:image_mono simp add: x2)
     then have *:"\<And>t. 0 < t \<Longrightarrow> t < d \<Longrightarrow> flow0 (flow0 x t2) t \<in> outer"
       by (smt \<open>r1 \<subseteq> outer\<close> greaterThanLessThan_iff mem_Sigma_iff pair_imageI r1_def subset_eq x2)
 
     then have t2o: "\<And>t. 0 < t \<Longrightarrow> t < d \<Longrightarrow> flow0 x (t2 + t) \<in> outer"
       using r1a3[OF x2] exist flow_trans
       by (metis (no_types, hide_lams) closed_segment_commute ends_in_segment(1) local.existence_ivl_trans' local.flow_undefined0 real_Icc_closed_segment subset_eq \<open>t1 \<le> t2\<close>)
 
 (* Construct a sequence of times converging to these points in r2 \<subseteq> inner *)
     have inner: "{a <--< flow0 x t2} \<subseteq> closure inner"
     proof (rule subsetI)
       fix y
       assume y: "y \<in> {a <--< flow0 x t2}"
       have [simp]: "y \<in> X"
         using y suba12_open suba2o \<open>{a -- b} \<subseteq> X\<close>
         by auto
       have "(\<forall>n. flow0 y (- d / real (Suc (Suc n))) \<in> inner)"
         using y
         using suba12_open \<open>0 < d\<close> suba2o \<open>{a -- b} \<subseteq> X\<close>
         by (auto intro!: set_mp[OF \<open>r2 \<subseteq> inner\<close>] image_eqI[where x="(y, -d/Suc (Suc n))" for n]
             simp: r2_def divide_simps) 
       moreover
       have d_over_0: "(\<lambda>s. - d / real (Suc (Suc s))) \<longlonglongrightarrow> 0"
         by (rule real_tendsto_divide_at_top)
           (auto intro!: filterlim_tendsto_add_at_top filterlim_real_sequentially)
       have "(\<lambda>n. flow0 y (- d / real (Suc (Suc n)))) \<longlonglongrightarrow> y"
         apply (rule tendsto_eq_intros)
            apply (rule tendsto_intros)
           apply (rule d_over_0)
         by auto
       ultimately show "y \<in> closure inner"
         unfolding closure_sequential
         by (intro exI[where x="\<lambda>n. flow0 y (-d/Suc (Suc n))"]) (rule conjI)
     qed
     then have "{a <--< flow0 x t1} \<subseteq> closure inner"
       using suba12_open by blast
     then have "{flow0 x t1 -- flow0 x t2} \<subseteq> closure inner"
       by (metis (no_types, lifting) closure_closure closure_mono closure_open_segment dual_order.trans inner subl x1neqx2)
     have outer:"\<And>t. t > t2 \<Longrightarrow> t \<in> existence_ivl0 x \<Longrightarrow> flow0 x t \<in> outer"
     proof (rule ccontr)
       fix t
       assume t: "t > t2" "t \<in> existence_ivl0 x" "flow0 x t \<notin> outer"
       have "0 \<le> t- (t2+d)" using t2o t  by smt 
       then have a2:"0 \<le> t - (t2+dr)" using d \<open>0 < dr\<close> \<open>dr < d\<close> by linarith
       have t2d2_ex: "t2 + dr \<in> existence_ivl0 x"
         using \<open>t1 \<le> t2\<close> exist d_ex[of "flow0 x t2"] \<open>flow0 x t2 \<in> {a--b}\<close> \<open>0 < d\<close> \<open>0 < dr\<close> \<open>dr < d\<close> 
         by (intro existence_ivl_trans) auto
       then have a3: "t - (t2 + dr) \<in> existence_ivl0 (flow0 x (t2 + dr))"
         using t(2)
         by (intro diff_existence_ivl_trans) auto
       then have "flow0 (flow0 x (t2 + dr)) (t - (t2 + dr)) = flow0 x t"
         by (subst flow_trans[symmetric]) (auto simp: t2d2_ex)
       moreover have "flow0 x t \<in> closure inner" using t(3) io
         by (metis ComplI Un_iff closure_Un_frontier)
       ultimately have a4: "flow0 (flow0 x (t2 + dr)) (t - (t2 + dr)) \<in> closure inner" by auto
       have a1: "flow0 x (t2+dr) \<in> outer"
         by (simp add: d t2o \<open>0 < dr\<close> \<open>dr < d\<close>)
       from outside_in[OF a1 a2 a3 a4]
       obtain T where T: "T > 0" "T \<le> t - (t2 + dr)"
         "(\<forall>s\<in>{0..<T}. flow0 (flow0 x (t2 + dr)) s \<in> outer)"
         "flow0 (flow0 x (t2 + dr)) T \<in> {flow0 x t1 --< flow0 x t2}" by blast
       define y where "y = flow0 (flow0 x (t2 + dr)) T"
       have "y \<in> {a <--< flow0 x t2}" unfolding y_def using T(4)
         using subl2 by blast 
       then have "(\<lambda>(x, y). flow0 x y)`({y} \<times> {-d<..<0}) \<subseteq> r2" unfolding r2_def
         by (auto intro!:image_mono)
       then have *:"\<And>t. -d < t \<Longrightarrow> t < 0 \<Longrightarrow> flow0 y t \<in> r2"
         by (simp add: pair_imageI subsetD)
       have "max (-T/2) dl < 0" using d T \<open>0 > dl\<close> \<open>dl > -d\<close> by auto
       moreover have "-d < max (-T/2) dl" using d T \<open>0 > dl\<close> \<open>dl > -d\<close> by auto
       ultimately have inner: "flow0 y (max (-T/2) dl) \<in> inner" using * \<open>r2 \<subseteq> inner\<close> by blast 
       have "0\<le>(T+(max (-T/2) dl))" using T(1) by linarith
       moreover have "(T+(max (-T/2) dl)) < T" using T(1) d \<open>0 > dl\<close> \<open>dl > -d\<close> by linarith
       ultimately have outer: " flow0 (flow0 x (t2 + dr)) (T+(max (-T/2) dl)) \<in> outer"
         using T by auto
       have T_ex: "T \<in> existence_ivl0 (flow0 x (t2 + dr))"
         apply (subst flow_trans)
         using exist \<open>t1 \<le> t2\<close>
         using d_ex[of "flow0 x t2"] \<open>flow0 x t2 \<in> {a -- b}\<close> \<open>d > 0\<close> T \<open>0 < dr\<close> \<open>dr < d\<close>
           apply (auto simp: )
         apply (rule set_rev_mp[where A="{0 .. t - (t2 + dr)}"], force)
         apply (rule ivl_subset_existence_ivl)
         apply (rule existence_ivl_trans')
          apply (rule existence_ivl_trans')
         by (auto simp: t)
       have T_ex2: "dr + T \<in> existence_ivl0 (flow0 x t2)"
         by (smt T_ex ends_in_segment(2) exist local.existence_ivl_trans local.existence_ivl_trans' real_Icc_closed_segment subset_eq t2d2_ex \<open>t1 \<le> t2\<close>)
       thus False using T \<open>t1 \<le> t2\<close> exist
         by (smt T_ex diff_existence_ivl_trans disjoint_iff_not_equal inner io(9) local.flow_trans local.flow_undefined0 outer y_def)
     qed
     have "closure inner \<inter> outer = {}"
       by (simp add: inf_sup_aci(1) io(5) io(9) open_Int_closure_eq_empty) 
     then have "flow0 x t \<notin> {a<--<flow0 x t2}"
       using \<open>t > t2\<close> \<open>t \<in> existence_ivl0 x\<close> inner outer by blast
   }
   moreover {
     assume "flow0 rp dr \<in> inner" "flow0 rp dl \<in> outer"
     then have
       r1i: "r1 \<inter> inner \<noteq> {}" and
       r2o: "r2 \<inter> outer \<noteq> {}" using rpr1 rpr2 by auto
     from path_connected_not_frontier_subset[OF pcr1 r1i]
     have "r1 \<subseteq> inner" using pir1 by (simp add: io(11))
     from path_connected_not_frontier_subset[OF pcr2 r2o]
     have "r2 \<subseteq> outer" using pir2 by (simp add: io(12))
 
     have "(\<lambda>(x, y). flow0 x y)`({flow0 x t2} \<times> {0<..<d}) \<subseteq> r1" unfolding r1_def
       by (auto intro!:image_mono simp add: x2)
     then have
       *:"\<And>t. 0 < t \<Longrightarrow> t < d \<Longrightarrow> flow0 (flow0 x t2) t \<in> inner"
       by (smt \<open>r1 \<subseteq> inner\<close> greaterThanLessThan_iff mem_Sigma_iff pair_imageI r1_def subset_eq x2)
 
     then have t2o: "\<And>t. 0 < t \<Longrightarrow> t < d \<Longrightarrow> flow0 x (t2 + t) \<in> inner"
       using r1a3[OF x2] exist flow_trans
       by (metis (no_types, hide_lams) closed_segment_commute ends_in_segment(1) local.existence_ivl_trans' local.flow_undefined0 real_Icc_closed_segment subset_eq \<open>t1 \<le> t2\<close>)
 
 (* Construct a sequence of times converging to these points in r2 \<subseteq> outer *)
     have outer: "{a <--< flow0 x t2} \<subseteq> closure outer"
     proof (rule subsetI)
       fix y
       assume y: "y \<in> {a <--< flow0 x t2}"
       have [simp]: "y \<in> X"
         using y suba12_open suba2o \<open>{a -- b} \<subseteq> X\<close>
         by auto
       have "(\<forall>n. flow0 y (- d / real (Suc (Suc n))) \<in> outer)"
         using y
         using suba12_open \<open>0 < d\<close> suba2o \<open>{a -- b} \<subseteq> X\<close>
         by (auto intro!: set_mp[OF \<open>r2 \<subseteq> outer\<close>] image_eqI[where x="(y, -d/Suc (Suc n))" for n]
             simp: r2_def divide_simps) 
       moreover
       have d_over_0: "(\<lambda>s. - d / real (Suc (Suc s))) \<longlonglongrightarrow> 0"
         by (rule real_tendsto_divide_at_top)
           (auto intro!: filterlim_tendsto_add_at_top filterlim_real_sequentially)
       have "(\<lambda>n. flow0 y (- d / real (Suc (Suc n)))) \<longlonglongrightarrow> y"
         apply (rule tendsto_eq_intros)
            apply (rule tendsto_intros)
           apply (rule d_over_0)
         by auto
       ultimately show "y \<in> closure outer"
         unfolding closure_sequential
         by (intro exI[where x="\<lambda>n. flow0 y (-d/Suc (Suc n))"]) (rule conjI)
     qed
     then have "{a <--< flow0 x t1} \<subseteq> closure outer"
       using suba12_open by blast
     then have "{flow0 x t1 -- flow0 x t2} \<subseteq> closure outer"
       by (metis (no_types, lifting) closure_closure closure_mono closure_open_segment dual_order.trans outer subl x1neqx2)
 
     have inner:"\<And>t. t > t2 \<Longrightarrow> t \<in> existence_ivl0 x \<Longrightarrow> flow0 x t \<in> inner"
     proof (rule ccontr)
       fix t
       assume t: "t > t2" "t \<in> existence_ivl0 x" "flow0 x t \<notin> inner"
       have "0 \<le> t- (t2+d)" using t2o t by smt 
       then have a2:"0 \<le> t - (t2+dr)" using d \<open>0 < dr\<close> \<open>dr < d\<close> by linarith
       have t2d2_ex: "t2 + dr \<in> existence_ivl0 x"
         using \<open>t1 \<le> t2\<close> exist d_ex[of "flow0 x t2"] \<open>flow0 x t2 \<in> {a--b}\<close> \<open>0 < d\<close> \<open>0 < dr\<close> \<open>dr < d\<close> 
         by (intro existence_ivl_trans) auto
       then have a3: "t - (t2 + dr) \<in> existence_ivl0 (flow0 x (t2 + dr))"
         using t(2)
         by (intro diff_existence_ivl_trans) auto
       then have "flow0 (flow0 x (t2 + dr)) (t - (t2 + dr)) = flow0 x t"
         by (subst flow_trans[symmetric]) (auto simp: t2d2_ex)
       moreover have "flow0 x t \<in> closure outer" using t(3) io
         by (metis ComplI Un_iff closure_Un_frontier)
       ultimately have a4: "flow0 (flow0 x (t2 + dr)) (t - (t2 + dr)) \<in> closure outer" by auto
       have a1: "flow0 x (t2+dr) \<in> inner"
         by (simp add: d t2o \<open>0 < dr\<close> \<open>dr < d\<close>)
       from inside_out[OF a1 a2 a3 a4]
       obtain T where T: "T > 0" "T \<le> t - (t2 + dr)"
         "(\<forall>s\<in>{0..<T}. flow0 (flow0 x (t2 + dr)) s \<in> inner)"
         "flow0 (flow0 x (t2 + dr)) T \<in> {flow0 x t1 --< flow0 x t2}" by blast
       define y where "y = flow0 (flow0 x (t2 + dr)) T"
       have "y \<in> {a <--< flow0 x t2}" unfolding y_def using T(4)
         using subl2 by blast 
       then have "(\<lambda>(x, y). flow0 x y)`({y} \<times> {-d<..<0}) \<subseteq> r2" unfolding r2_def
         by (auto intro!:image_mono)
       then have *:"\<And>t. -d < t \<Longrightarrow> t < 0 \<Longrightarrow> flow0 y t \<in> r2"
         by (simp add: pair_imageI subsetD)
       have "max (-T/2) dl < 0" using d T \<open>0 > dl\<close> \<open>dl > -d\<close> by auto
       moreover have "-d < max (-T/2) dl" using d T \<open>0 > dl\<close> \<open>dl > -d\<close> by auto
       ultimately have outer: "flow0 y (max (-T/2) dl) \<in> outer" using * \<open>r2 \<subseteq> outer\<close> by blast 
       have "0\<le>(T+(max (-T/2) dl))" using T(1) by linarith
       moreover have "(T+(max (-T/2) dl)) < T" using T(1) d \<open>0 > dl\<close> \<open>dl > -d\<close> by linarith
       ultimately have inner: " flow0 (flow0 x (t2 + dr)) (T+(max (-T/2) dl)) \<in> inner"
         using T by auto
       have T_ex: "T \<in> existence_ivl0 (flow0 x (t2 + dr))"
         apply (subst flow_trans)
         using exist \<open>t1 \<le> t2\<close>
         using d_ex[of "flow0 x t2"] \<open>flow0 x t2 \<in> {a -- b}\<close> \<open>d > 0\<close> T \<open>0 < dr\<close> \<open>dr < d\<close>
           apply (auto simp: )
         apply (rule set_rev_mp[where A="{0 .. t - (t2 + dr)}"], force)
         apply (rule ivl_subset_existence_ivl)
         apply (rule existence_ivl_trans')
          apply (rule existence_ivl_trans')
         by (auto simp: t)
       have T_ex2: "dr + T \<in> existence_ivl0 (flow0 x t2)"
         by (smt T_ex ends_in_segment(2) exist local.existence_ivl_trans local.existence_ivl_trans' real_Icc_closed_segment subset_eq t2d2_ex \<open>t1 \<le> t2\<close>)
       thus False using T \<open>t1 \<le> t2\<close> exist
         by (smt T_ex diff_existence_ivl_trans disjoint_iff_not_equal inner io(9) local.flow_trans local.flow_undefined0 outer y_def)
     qed
     have "closure outer \<inter> inner = {}"
       by (metis inf_sup_aci(1) io(2) io2(1) open_Int_closure_eq_empty)
     then have "flow0 x t \<notin> {a<--<flow0 x t2}"
       using \<open>t > t2\<close> \<open>t \<in> existence_ivl0 x\<close> inner outer by blast
   }
   ultimately show
     "flow0 x t \<notin> {a<--<flow0 x t2}" by auto
 qed
 
 lemma open_segment_trichotomy:
   fixes x y a b::'a
   assumes x:"x \<in> {a<--<b}"
   assumes y:"y \<in> {a<--<b}"
   shows "x = y \<or> y \<in> {x<--<b} \<or> y \<in> {a<--<x}"
 proof -
   from Un_open_segment[OF y]
   have "{a<--<y} \<union> {y} \<union> {y<--<b} = {a<--<b}" .
   then have "x \<in> {a<--<y} \<or> x = y \<or> x \<in> {y <--<b}" using x by blast
   moreover {
     assume "x \<in> {a<--<y}"
     then have "y \<in> {x<--<b}" using open_segment_subsegment
       using open_segment_commute y by blast
   }
   moreover {
     assume "x \<in> {y<--<b}"
     from open_segment_subsegment[OF y this]
     have "y \<in> {a<--<x}" .
   }
   ultimately show ?thesis by blast
 qed
 
 sublocale rev: c1_on_open_R2 "-f" "-f'" rewrites "-(-f) = f" and "-(-f') = f'"
   by unfold_locales (auto simp: dim2)
 
 lemma rev_transversal_segment: "rev.transversal_segment a b = transversal_segment a b"
   by (auto simp: transversal_segment_def rev.transversal_segment_def)
 
 lemma flow0_transversal_segment_monotone_step_reverse:
   assumes "transversal_segment a b"
   assumes "t1 \<le> t2"
   assumes "{t1..t2} \<subseteq> existence_ivl0 x"
   assumes x1: "flow0 x t1 \<in> {a<--<b}"
   assumes x2: "flow0 x t2 \<in> {a<--<flow0 x t1}"
   assumes "\<And>t. t \<in> {t1<..<t2} \<Longrightarrow> flow0 x t \<notin> {a<--<b}"
   assumes "t < t1" "t \<in> existence_ivl0 x"
   shows "flow0 x t \<notin> {a<--<flow0 x t1}"
 proof -
   note exist = \<open>{t1..t2} \<subseteq> existence_ivl0 x\<close>
   note t1t2 = \<open>\<And>t. t \<in> {t1<..<t2} \<Longrightarrow> flow0 x t \<notin> {a<--<b}\<close>
   from \<open>transversal_segment a b\<close> have [simp]: "a \<noteq> b" by (simp add: transversal_segment_def)
   from x1 obtain i1 where i1: "flow0 x t1 = line a b i1" "0 < i1" "i1 < 1"
     by (auto simp: in_open_segment_iff_line)
   from x2 obtain i2 where i2: "flow0 x t2 = line a b i2" "0 < i2" "i2 < i1"
     by (auto simp: i1 open_segment_line_iff)
 
   have t2_exist[simp]: "t2 \<in> existence_ivl0 x"
     using \<open>t1 \<le> t2\<close> exist by auto
   have t2_mem: "flow0 x t2 \<in> {a<--<b}"
     and x1_mem: "flow0 x t1 \<in> {flow0 x t2<--<b}"
     using i1 i2
     by (auto simp: line_in_subsegment line_line1)
 
   have transversal': "rev.transversal_segment a b"
     using \<open>transversal_segment a b\<close> unfolding rev_transversal_segment .
   have time': "0 \<le> t2 - t1" using \<open>t1 \<le> t2\<close> by simp
   have [simp, intro]: "flow0 x t2 \<in> X"
     using exist \<open>t1 \<le> t2\<close>
     by auto
   have exivl': "{0..t2 - t1} \<subseteq> rev.existence_ivl0 (flow0 x t2)"
     using exist \<open>t1 \<le> t2\<close>
     by (force simp add: rev_existence_ivl_eq0 intro!: existence_ivl_trans')
   have step': "rev.flow0 (flow0 x t2) (t2-t) \<notin>  {a<--<rev.flow0 (flow0 x t2) (t2 - t1)}"
     apply (rule rev.flow0_transversal_segment_monotone_step[OF transversal' time' exivl'])
     using exist \<open>t1 \<le> t2\<close> x1 x2 t2_mem x1_mem t1t2 \<open>t < t1\<close> \<open>t \<in> existence_ivl0 x\<close>
         apply (auto simp: rev_existence_ivl_eq0 rev_eq_flow existence_ivl_trans' flow_trans[symmetric])
     by (subst (asm) flow_trans[symmetric]) (auto intro!: existence_ivl_trans')
   then show ?thesis
     unfolding rev_eq_flow
     using \<open>t1 \<le> t2\<close> exist \<open>t < t1\<close> \<open>t \<in> existence_ivl0 x\<close>
     by (auto simp: flow_trans[symmetric] existence_ivl_trans')
 qed
 
 lemma flow0_transversal_segment_monotone_step_reverse2:
   assumes transversal: "transversal_segment a b"
   assumes time: "t1 \<le> t2"
   assumes exist: "{t1..t2} \<subseteq> existence_ivl0 x"
   assumes t1: "flow0 x t1 \<in> {a<--<b}"
   assumes t2: "flow0 x t2 \<in> {flow0 x t1<--<b}"
   assumes t1t2: "\<And>t. t \<in> {t1<..<t2} \<Longrightarrow> flow0 x t \<notin> {a<--<b}"
   assumes t: "t < t1" "t \<in> existence_ivl0 x"
   shows "flow0 x t \<notin> {flow0 x t1<--<b}"
   using flow0_transversal_segment_monotone_step_reverse[of b a, OF _ time exist, of t]
     assms
   by (auto simp: open_segment_commute transversal_segment_commute)
 
 lemma flow0_transversal_segment_monotone_step2:
   assumes transversal: "transversal_segment a b"
   assumes time: "t1 \<le> t2"
   assumes exist: "{t1..t2} \<subseteq> existence_ivl0 x"
   assumes t1: "flow0 x t1 \<in> {a<--<b}"
   assumes t2: "flow0 x t2 \<in> {a<--<flow0 x t1}"
   assumes t1t2: "\<And>t. t \<in> {t1<..<t2} \<Longrightarrow> flow0 x t \<notin> {a<--<b}"
   shows "\<And>t. t > t2 \<Longrightarrow> t \<in> existence_ivl0 x \<Longrightarrow> flow0 x t \<notin> {flow0 x t2<--<b}"
   using flow0_transversal_segment_monotone_step[of b a, OF _ time exist]
     assms
   by (auto simp: transversal_segment_commute open_segment_commute)
 
 lemma flow0_transversal_segment_monotone:
   assumes "transversal_segment a b"
   assumes "t1 \<le> t2"
   assumes "{t1..t2} \<subseteq> existence_ivl0 x"
   assumes x1: "flow0 x t1 \<in> {a<--<b}"
   assumes x2: "flow0 x t2 \<in> {flow0 x t1<--<b}"
   assumes "t > t2" "t \<in> existence_ivl0 x"
   shows "flow0 x t \<notin> {a<--<flow0 x t2}"
 proof -
   note exist = \<open>{t1..t2} \<subseteq> existence_ivl0 x\<close>
   note t = \<open>t > t2\<close> \<open>t \<in> existence_ivl0 x\<close>
   have x1neqx2: "flow0 x t1 \<noteq> flow0 x t2"
     using open_segment_def x2 by force 
   then have t1neqt2: "t1 \<noteq> t2" by auto
   with \<open>t1 \<le> t2\<close> have "t1 < t2" by simp
 
   from \<open>transversal_segment a b\<close> have [simp]: "a \<noteq> b" by (simp add: transversal_segment_def)
   from x1 obtain i1 where i1: "flow0 x t1 = line a b i1" "0 < i1" "i1 < 1"
     by (auto simp: in_open_segment_iff_line)
   from x2 i1 obtain i2 where i2: "flow0 x t2 = line a b i2" "i1 < i2" "i2 < 1"
     by (auto simp: line_open_segment_iff)
   have t2_in: "flow0 x t2 \<in> {a<--<b}"
     using i1 i2
     by simp
 
   let ?T = "{s \<in> {t1..t2}. flow0 x s \<in> {a--b}}"
   let ?T' = "{s \<in> {t1..<t2}. flow0 x s \<in> {a<--<b}}"
   from flow_transversal_segment_finite_intersections[OF \<open>transversal_segment a b\<close> \<open>t1 \<le> t2\<close> exist]
   have "finite ?T" .
   then have "finite ?T'" by (rule finite_subset[rotated]) (auto simp: open_closed_segment)
   have "?T' \<noteq> {}"
     by (auto intro!: exI[where x=t1] \<open>t1 < t2\<close> x1)
   note tm_defined = \<open>finite ?T'\<close> \<open>?T' \<noteq> {}\<close>
   define tm where "tm = Max ?T'"
   have "tm \<in> ?T'"
     unfolding tm_def
     using tm_defined by (rule Max_in)
   have tm_in: "flow0 x tm \<in> {a<--<b}"
     using \<open>tm \<in> ?T'\<close>
     by auto
   have tm: "t1 \<le> tm" "tm < t2" "tm \<le> t2"
     using \<open>tm \<in> ?T'\<close> by auto
   have tm_Max: "t \<le> tm" if "t \<in> ?T'" for t
     unfolding tm_def
     using tm_defined(1) that
     by (rule Max_ge)
 
   have tm_exclude: "flow0 x t \<notin> {a<--<b}" if "t \<in> {tm<..<t2}" for t
     using \<open>tm \<in> ?T'\<close> tm_Max that
     by auto (meson approximation_preproc_push_neg(2) dual_order.strict_trans2 le_cases)
   have "{tm..t2} \<subseteq> existence_ivl0 x"
     using exist tm by auto
 
   from open_segment_trichotomy[OF tm_in t2_in]
   consider
     "flow0 x t2 \<in> {flow0 x tm<--<b}" |
     "flow0 x t2 \<in> {a<--<flow0 x tm}" |
     "flow0 x tm = flow0 x t2"
     by blast
   then show "flow0 x t \<notin> {a<--<flow0 x t2}"
   proof cases
     case 1
     from flow0_transversal_segment_monotone_step[OF \<open>transversal_segment a b\<close> \<open>tm \<le> t2\<close>
         \<open>{tm..t2} \<subseteq> existence_ivl0 x\<close> tm_in 1 tm_exclude t]
     show ?thesis .
   next
     case 2
     have "t1 \<noteq> tm"
       using 2 x2 i1 i2
       by (auto simp: line_in_subsegment line_in_subsegment2)
     then have "t1 < tm" using \<open>t1 \<le> tm\<close> by simp
     from flow0_transversal_segment_monotone_step_reverse[OF \<open>transversal_segment a b\<close> \<open>tm \<le> t2\<close>
         \<open>{tm..t2} \<subseteq> existence_ivl0 x\<close> tm_in 2 tm_exclude \<open>t1 < tm\<close>] exist \<open>t1 \<le> t2\<close>
     have "flow0 x t1 \<notin> {a<--<flow0 x tm}" by auto
     then have False
       using x1 x2 2 i1 i2
       apply (auto simp: line_in_subsegment line_in_subsegment2)
       by (smt greaterThanLessThan_iff in_open_segment_iff_line line_in_subsegment2 tm_in)
     then show ?thesis by simp
   next
     case 3
     have "t1 \<noteq> tm"
       using 3 x2
       by (auto simp: open_segment_def)
     then have "t1 < tm" using \<open>t1 \<le> tm\<close> by simp
     have "range (flow0 x) = flow0 x ` {tm..t2}"
       apply (rule recurrence_time_restricts_compact_flow'[OF \<open>tm < t2\<close> _ _ 3])
       using exist \<open>t1 \<le> t2\<close> \<open>t1 < tm\<close> \<open>tm < t2\<close>
       by auto
     also have "\<dots> = flow0 x ` (insert t2 {tm<..<t2})"
       using \<open>tm \<le> t2\<close> 3
       apply (auto simp: )
       by (smt greaterThanLessThan_iff image_eqI)
     finally have "flow0 x t1 \<in> flow0 x ` (insert t2 {tm<..<t2})"
       by auto
     then have "flow0 x t1 \<in> flow0 x ` {tm<..<t2}" using x1neqx2
       by auto
     moreover have "\<dots> \<inter> {a<--<b} = {}"
       using tm_exclude
       by auto
     ultimately have False using x1 by auto
     then show ?thesis by blast
   qed
 qed
 
 subsection \<open>Straightening\<close>
 
 text \<open> This lemma uses the implicit function theorem \<close>
 lemma cross_time_continuous:
   assumes "transversal_segment a b"
   assumes "x \<in> {a<--<b}"
   assumes "e > 0"
   obtains d t where "d > 0" "continuous_on (ball x d) t"
     "\<And>y. y \<in> ball x d \<Longrightarrow> flow0 y (t y) \<in> {a<--<b}"
     "\<And>y. y \<in> ball x d \<Longrightarrow> \<bar>t y\<bar> < e"
     "continuous_on (ball x d) t"
     "t x = 0"
 proof -
   have "x \<in> X" using assms segment_open_subset_closed[of a b]
     by (auto simp: transversal_segment_def)
   have "a \<noteq> b" using assms by auto
   define s where "s x = (x - a) \<bullet> rot (b - a)" for x
   have "s x = 0"
     unfolding s_def
     by (subst in_segment_inner_rot) (auto intro!: assms open_closed_segment)
   have Ds: "(s has_derivative blinfun_inner_left (rot (b - a))) (at x)"
     (is "(_ has_derivative blinfun_apply (?Ds x)) _")
     for x
     unfolding s_def
     by (auto intro!: derivative_eq_intros)
   have Dsc: "isCont ?Ds x" by (auto intro!: continuous_intros)
   have nz: "?Ds x (f x) \<noteq> 0"
     using assms  apply auto
     unfolding transversal_segment_def
     by (smt inner_minus_left nrm_reverse open_closed_segment)
 
   from flow_implicit_function_at[OF \<open>x \<in> X\<close>, of s, OF \<open>s x = 0\<close> Ds Dsc nz \<open>e > 0\<close>]
   obtain t d1 where "0 < d1"
     and t0: "t x = 0"
     and d1: "(\<And>y. y \<in> cball x d1 \<Longrightarrow> s (flow0 y (t y)) = 0)"
     "(\<And>y. y \<in> cball x d1 \<Longrightarrow> \<bar>t y\<bar> < e)"
     "(\<And>y. y \<in> cball x d1 \<Longrightarrow> t y \<in> existence_ivl0 y)"
     and tc: "continuous_on (cball x d1) t"
     and t': "(t has_derivative
         (- blinfun_inner_left (rot (b - a)) /\<^sub>R (blinfun_inner_left (rot (b - a))) (f x)))
       (at x)"
     by metis
   from tc
   have "t \<midarrow>x\<rightarrow> 0"
     using \<open>0 < d1\<close>
     by (auto simp: continuous_on_def at_within_interior t0 dest!: bspec[where x=x])
   then have ftc: "((\<lambda>y. flow0 y (t y)) \<longlongrightarrow> x) (at x)"
     by (auto intro!: tendsto_eq_intros simp: \<open>x \<in> X\<close>)
 
 
 
   define e2 where "e2 = min (dist a x) (dist b x)"
   have "e2 > 0"
     using assms
     by (auto simp: e2_def open_segment_def)
 
   from tendstoD[OF ftc this] have "\<forall>\<^sub>F y in at x. dist (flow0 y (t y)) x < e2" .
   moreover
   let ?S = "{x. a \<bullet> (b - a) < x \<bullet> (b - a) \<and> x \<bullet> (b - a) < b \<bullet> (b - a)}"
   have "open ?S" "x \<in> ?S"
     using \<open>x \<in> {a<--<b}\<close>
     by (auto simp add: open_segment_line_hyperplanes \<open>a \<noteq> b\<close>
         intro!: open_Collect_conj open_halfspace_component_gt open_halfspace_component_lt)
   from topological_tendstoD[OF ftc this] have "\<forall>\<^sub>F y in at x. flow0 y (t y) \<in> ?S" .
   ultimately
   have "\<forall>\<^sub>F y in at x. flow0 y (t y) \<in> ball x e2 \<inter> ?S" by eventually_elim (auto simp: dist_commute)
   then obtain d2 where "0 < d2" and "\<And>y. x \<noteq> y \<Longrightarrow> dist y x < d2 \<Longrightarrow> flow0 y (t y) \<in> ball x e2 \<inter> ?S"
     by (force simp: eventually_at)
   then have d2: "dist y x < d2 \<Longrightarrow> flow0 y (t y) \<in> ball x e2 \<inter> ?S" for y
     using \<open>0 < e2\<close> \<open>x \<in> X\<close> t0 \<open>x \<in> ?S\<close>
     by (cases "y = x") auto
 
   define d where "d = min d1 d2"
   have "d > 0" using \<open>0 < d1\<close> \<open>0 < d2\<close> by (simp add: d_def)
   moreover have "continuous_on (ball x d) t"
     by (auto intro!:continuous_on_subset[OF tc] simp add: d_def)
   moreover
   have "ball x e2 \<inter> ?S \<inter> {x. s x = 0} \<subseteq> {a<--<b}"
     by (auto simp add: in_open_segment_iff_rot \<open>a \<noteq> b\<close>) (auto simp: s_def e2_def in_segment)
   then have "\<And>y. y \<in> ball x d \<Longrightarrow> flow0 y (t y) \<in> {a<--<b}"
     apply (rule set_mp)
     using d1 d2 \<open>0 < d2\<close>
     by (auto simp: d_def e2_def dist_commute)
   moreover have "\<And>y. y \<in> ball x d \<Longrightarrow> \<bar>t y\<bar> < e"
     using d1 by (auto simp: d_def)
   moreover have "continuous_on (ball x d) t"
     using tc by (rule continuous_on_subset) (auto simp: d_def)
   moreover have "t x = 0" by (simp add: t0)
   ultimately show ?thesis ..
 qed
 
 lemma \<omega>_limit_crossings:
   assumes "transversal_segment a b"
   assumes pos_ex: "{0..} \<subseteq> existence_ivl0 x"
   assumes "\<omega>_limit_point x p"
   assumes "p \<in> {a<--<b}"
   obtains s where 
     "s \<longlonglongrightarrow>\<^bsub>\<^esub> \<infinity>"
     "(flow0 x \<circ> s) \<longlonglongrightarrow> p"
     "\<forall>\<^sub>F n in sequentially. flow0 x (s n) \<in> {a<--<b} \<and> s n \<in> existence_ivl0 x"
 proof -
   from assms have "p \<in> X" by (auto simp: transversal_segment_def open_closed_segment)
   from assms(3)
   obtain t where
     "t \<longlonglongrightarrow>\<^bsub>\<^esub> \<infinity>" "(flow0 x \<circ> t) \<longlonglongrightarrow> p"
     by (auto simp: \<omega>_limit_point_def)
   note t = \<open>t \<longlonglongrightarrow>\<^bsub>\<^esub> \<infinity>\<close> \<open>(flow0 x \<circ> t) \<longlonglongrightarrow> p\<close>
   note [tendsto_intros] = t(2)
   from cross_time_continuous[OF assms(1,4) zero_less_one\<comment> \<open>TODO ??\<close>]
   obtain \<tau> \<delta>
     where "0 < \<delta>" "continuous_on (ball p \<delta>) \<tau>" 
       "\<tau> p = 0" "(\<And>y. y \<in> ball p \<delta> \<Longrightarrow> \<bar>\<tau> y\<bar> < 1)"
       "(\<And>y. y \<in> ball p \<delta> \<Longrightarrow> flow0 y (\<tau> y) \<in> {a<--<b})"
     by metis
   note \<tau> =
     \<open>(\<And>y. y \<in> ball p \<delta> \<Longrightarrow> flow0 y (\<tau> y) \<in> {a<--<b})\<close>
     \<open>(\<And>y. y \<in> ball p \<delta> \<Longrightarrow> \<bar>\<tau> y\<bar> < 1)\<close>
     \<open>continuous_on (ball p \<delta>) \<tau>\<close> \<open>\<tau> p = 0\<close>
   define s where "s n = t n + \<tau> (flow0 x (t n))" for n
   have ev_in_ball: "\<forall>\<^sub>F n in at_top. flow0 x (t n) \<in> ball p \<delta>"
     apply (simp add: )
     apply (subst dist_commute)
     apply (rule tendstoD)
      apply (rule t[unfolded o_def])
     apply (rule \<open>0 < \<delta>\<close>)
     done
   have "filterlim s at_top sequentially"
   proof (rule filterlim_at_top_mono)
     show "filterlim (\<lambda>n. -1 + t n) at_top sequentially"
       by (rule filterlim_tendsto_add_at_top) (auto intro!: filterlim_tendsto_add_at_top t)
     from ev_in_ball show "\<forall>\<^sub>F x in sequentially. -1 + t x \<le> s x"
       apply eventually_elim
       using \<tau>
       by (force simp : s_def)
   qed
   moreover
   have \<tau>_cont: "\<tau> \<midarrow>p\<rightarrow> \<tau> p"
     using \<tau>(3) \<open>0 < \<delta>\<close>
     by (auto simp: continuous_on_def at_within_ball dest!: bspec[where x=p])
   note [tendsto_intros] = tendsto_compose_at[OF _ this, simplified]
   have ev1: "\<forall>\<^sub>F n in sequentially. t n > 1"
     using filterlim_at_top_dense t(1) by auto
   then have ev_eq: "\<forall>\<^sub>F n in sequentially. flow0 ((flow0 x o t) n) ((\<tau> o (flow0 x o t)) n) = (flow0 x o s) n"
     using ev_in_ball
     apply (eventually_elim)
     apply (drule \<tau>(2))
     unfolding o_def
     apply (subst flow_trans[symmetric])
     using pos_ex
       apply (auto simp: s_def)
     apply (rule existence_ivl_trans')
     by auto
   then
   have "\<forall>\<^sub>F n in sequentially.
   (flow0 x o s) n = flow0 ((flow0 x o t) n) ((\<tau> o (flow0 x o t)) n)"
     by (simp add: eventually_mono)
   from \<open>(flow0 x \<circ> t) \<longlonglongrightarrow> p\<close> and \<open>\<tau> \<midarrow>p\<rightarrow> \<tau> p\<close>
   have
     "(\<lambda>n. flow0 ((flow0 x \<circ> t) n) ((\<tau> \<circ> (flow0 x \<circ> t)) n))
   \<longlonglongrightarrow>
   flow0 p (\<tau> p)"
     using \<open>\<tau> p = 0\<close> \<tau>_cont \<open>p \<in> X\<close>
     by (intro tendsto_eq_intros) auto
-  with ev_eq have "(flow0 x o s) \<longlonglongrightarrow> flow0 p (\<tau> p)"
-    by (rule Lim_transform_eventually)
+  then have "(flow0 x o s) \<longlonglongrightarrow> flow0 p (\<tau> p)"
+    using ev_eq by (rule Lim_transform_eventually)
   then have "(flow0 x o s) \<longlonglongrightarrow> p"
     using \<open>p \<in> X\<close> \<open>\<tau> p = 0\<close>
     by simp
   moreover
   {
     have "\<forall>\<^sub>F n in sequentially. flow0 x (s n) \<in> {a<--<b}"
       using ev_eq ev_in_ball
       apply eventually_elim
       apply (drule sym)
       apply simp
       apply (rule \<tau>) by simp
     moreover have "\<forall>\<^sub>F n in sequentially. s n \<in> existence_ivl0 x"
       using ev_in_ball ev1
       apply (eventually_elim)
       apply (drule \<tau>(2))
       using pos_ex
       by (auto simp: s_def)
     ultimately have "\<forall>\<^sub>F n in sequentially. flow0 x (s n) \<in> {a<--<b} \<and> s n \<in> existence_ivl0 x"
       by eventually_elim auto
   }
   ultimately show ?thesis ..
 qed
 
 (* Obvious but frequently used step *)
 lemma filterlim_at_top_tendstoE:
   assumes "e > 0"
   assumes "filterlim s at_top sequentially"
   assumes "(flow0 x \<circ> s) \<longlonglongrightarrow> u"
   assumes "\<forall>\<^sub>F n in sequentially. P (s n)"
   obtains m where "m > b" "P m" "dist (flow0 x m) u < e"
 proof -
   from assms(2) have "\<forall>\<^sub>F n in sequentially. b < s n"
     by (simp add: filterlim_at_top_dense)
   moreover have "\<forall>\<^sub>F n in sequentially. norm ((flow0 x \<circ> s) n - u) < e"
     using assms(3)[THEN tendstoD, OF assms(1)] by (simp add: dist_norm)
   moreover note assms(4)
   ultimately have "\<forall>\<^sub>F n in sequentially. b < s n \<and> norm ((flow0 x \<circ> s) n - u) < e \<and> P (s n)"
     by eventually_elim auto
   then obtain m where "m > b" "P m" "dist (flow0 x m) u < e"
     by (auto simp add: eventually_sequentially dist_norm)
   then show ?thesis ..
 qed
 
 lemma open_segment_separate_left:
   fixes u v x a b::'a
   assumes u:"u \<in> {a <--< b}"
   assumes v:"v \<in> {u <--< b}"
   assumes x: "dist x u < dist u v" "x \<in> {a <--< b}"
   shows "x \<in> {a <--< v}"
 proof -
   have "v \<noteq> x"
     by (smt dist_commute x(1)) 
   moreover have "x \<notin> {v<--<b}"
     by (smt dist_commute dist_in_open_segment open_segment_subsegment v x(1))
   moreover have "v \<in> {a<--<b}" using v
     by (metis ends_in_segment(1) segment_open_subset_closed subset_eq subset_segment(4) u)
   ultimately show ?thesis using open_segment_trichotomy[OF _ x(2)]
     by blast
 qed
 
 lemma open_segment_separate_right:
   fixes u v x a b::'a
   assumes u:"u \<in> {a <--< b}"
   assumes v:"v \<in> {a <--< u}"
   assumes x: "dist x u < dist u v" "x \<in> {a <--< b}"
   shows "x \<in> {v <--< b}"
 proof -
   have "v \<noteq> x"
     by (smt dist_commute x(1))
   moreover have "x \<notin> {a<--<v}"
     by (smt dist_commute dist_in_open_segment open_segment_commute open_segment_subsegment v x(1))
   moreover have "v \<in> {a<--<b}" using v
     by (metis ends_in_segment(1) segment_open_subset_closed subset_eq subset_segment(4) u)
   ultimately show ?thesis using open_segment_trichotomy[OF _ x(2)]
     by blast
 qed
 
 lemma no_two_\<omega>_limit_points:
   assumes transversal: "transversal_segment a b"
   assumes ex_pos: "{0..} \<subseteq> existence_ivl0 x"
   assumes u: "\<omega>_limit_point x u" "u \<in> {a<--<b}"
   assumes v: "\<omega>_limit_point x v" "v \<in> {a<--<b}"
   assumes uv: "v \<in> {u<--<b}"
   shows False
 proof -
   have unotv: "u \<noteq> v" using uv
     using dist_in_open_segment by blast 
   define duv where "duv = dist u v / 2"
   have duv: "duv > 0" unfolding duv_def using unotv by simp
   from \<omega>_limit_crossings[OF transversal ex_pos u]
   obtain su where su: "filterlim su at_top sequentially"
     "(flow0 x \<circ> su) \<longlonglongrightarrow> u"
     "\<forall>\<^sub>F n in sequentially. flow0 x (su n) \<in> {a<--<b} \<and> su n \<in> existence_ivl0 x" by blast
   from \<omega>_limit_crossings[OF transversal ex_pos v]
   obtain sv where sv: "filterlim sv at_top sequentially"
     "(flow0 x \<circ> sv) \<longlonglongrightarrow> v"
     "\<forall>\<^sub>F n in sequentially. flow0 x (sv n) \<in> {a<--<b} \<and> sv n \<in> existence_ivl0 x" by blast
   from filterlim_at_top_tendstoE[OF duv su]
   obtain su1 where su1:"su1 > 0" "flow0 x su1 \<in> {a<--<b}"
     "su1 \<in> existence_ivl0 x" "dist (flow0 x su1) u < duv" by auto
   from filterlim_at_top_tendstoE[OF duv sv, of su1]
   obtain su2 where su2:"su2 > su1" "flow0 x su2 \<in> {a<--<b}"
     "su2 \<in> existence_ivl0 x" "dist (flow0 x su2) v < duv" by auto
   from filterlim_at_top_tendstoE[OF duv su, of su2]
   obtain su3 where su3:"su3 > su2" "flow0 x su3 \<in> {a<--<b}"
     "su3 \<in> existence_ivl0 x" "dist (flow0 x su3) u < duv" by auto
   have *: "su1 \<le> su2" "{su1..su2} \<subseteq> existence_ivl0 x" using su1 su2
      apply linarith
     by (metis atLeastatMost_empty_iff empty_iff mvar.closed_segment_subset_domain real_Icc_closed_segment su1(3) su2(3) subset_eq)
 
 (* by construction *)
   have d1: "dist (flow0 x su1) v \<ge> (dist u v)/2" using su1(4) duv unfolding duv_def
     by (smt dist_triangle_half_r)
   have "dist (flow0 x su1) u < dist u v" using su1(4) duv unfolding duv_def by linarith
   from open_segment_separate_left[OF u(2) uv this su1(2)]
   have su1l:"flow0 x su1 \<in> {a<--<v}" .
   have "dist (flow0 x su2) v < dist v (flow0 x su1)" using d1
     by (smt dist_commute duv_def su2(4))
   from open_segment_separate_right[OF v(2) su1l this su2(2)]
   have su2l:"flow0 x su2 \<in> {flow0 x su1<--<b}" .
   then have su2ll:"flow0 x su2 \<in> {u<--<b}"
     by (smt dist_commute dist_pos_lt duv_def open_segment_subsegment pos_half_less open_segment_separate_right su2(2) su2(4) u(2) uv v(2) unotv)
 
   have "dist (flow0 x su2) u \<ge> (dist u v)/2" using su2(4) duv unfolding duv_def
     by (smt dist_triangle_half_r)
   then have "dist (flow0 x su3) u < dist u (flow0 x su2)"
     by (smt dist_commute duv_def su3(4)) 
   from open_segment_separate_left[OF u(2) su2ll this su3(2)]
   have su3l:"flow0 x su3 \<in> {a<--<flow0 x su2}" .
 
   from flow0_transversal_segment_monotone[OF transversal * su1(2) su2l su3(1) su3(3)]
   have "flow0 x su3 \<notin> {a <--<flow0 x su2}" .
   thus False using su3l by auto
 qed
 
 
 subsection \<open>Unique Intersection\<close>
 
 text \<open>Perko Section 3.7 Remark 2\<close>
 lemma unique_transversal_segment_intersection:
   assumes "transversal_segment a b"
   assumes "{0..} \<subseteq> existence_ivl0 x"
   assumes "u \<in> \<omega>_limit_set x \<inter> {a<--<b}"
   shows "\<omega>_limit_set x \<inter> {a<--<b} = {u}"
 proof (rule ccontr)
   assume "\<omega>_limit_set x \<inter> {a<--<b} \<noteq> {u}"
   then
   obtain v where uv: "u \<noteq> v"
     and v: "\<omega>_limit_point x v" "v \<in> {a<--<b}" using assms unfolding \<omega>_limit_set_def
     by fastforce
   have u:"\<omega>_limit_point x u" "u \<in> {a<--<b}" using assms unfolding \<omega>_limit_set_def
     by auto
   show False using no_two_\<omega>_limit_points[OF \<open>transversal_segment a b\<close>]
     by (smt dist_commute dist_in_open_segment open_segment_trichotomy u uv v assms)
 qed
 
 text \<open>Adapted from Perko Section 3.7 Lemma 4 (+ Chicone )\<close>
 lemma periodic_imp_\<omega>_limit_set:
   assumes "compact K" "K \<subseteq> X"
   assumes "x \<in> X" "trapped_forward x K"
   assumes "periodic_orbit y"
     "flow0 y ` UNIV \<subseteq> \<omega>_limit_set x"
   shows "flow0 y `UNIV = \<omega>_limit_set x"
 proof (rule ccontr)
   note y = \<open>periodic_orbit y\<close> \<open>flow0 y ` UNIV \<subseteq> \<omega>_limit_set x\<close>
   from trapped_sol_right[OF assms(1-4)] 
   have ex_pos: "{0..} \<subseteq> existence_ivl0 x" by blast
   assume "flow0 y `UNIV \<noteq> \<omega>_limit_set x"
   obtain p where p: "p \<in> \<omega>_limit_set x" "p \<notin> flow0 y ` UNIV"
     using y(2) apply auto
     using \<open>range (flow0 y) \<noteq> \<omega>_limit_set x\<close> by blast
   from \<omega>_limit_set_in_compact_connected[OF assms(1-4)] have
     wcon: "connected (\<omega>_limit_set x)" .
   from \<omega>_limit_set_invariant have
     "invariant (\<omega>_limit_set x)" .
   from \<omega>_limit_set_in_compact_compact[OF assms(1-4)] have
     "compact (\<omega>_limit_set x)" .
   then have sc: "seq_compact (\<omega>_limit_set x)"
     using compact_imp_seq_compact by blast
   have y1:"closed (flow0 y ` UNIV)"
     using closed_orbit_\<omega>_limit_set periodic_orbit_def \<omega>_limit_set_closed y(1) by auto
   have y2: "flow0 y ` UNIV \<noteq> {}" by simp 
   let ?py = "infdist p (range (flow0 y))"
   have "0 < ?py"
     using y1 y2 p(2)
     by (rule infdist_pos_not_in_closed)
   have "\<forall>n::nat. \<exists>z. z \<in> \<omega>_limit_set x - flow0 y ` UNIV \<and>
     infdist z (flow0 y ` UNIV) < ?py/2^n"
   proof (rule ccontr)
     assume " \<not> (\<forall>n. \<exists>z. z \<in> \<omega>_limit_set x - range (flow0 y) \<and>
                 infdist z (range (flow0 y))
                 < infdist p (range (flow0 y)) / 2 ^ n) "
     then obtain n where n: "(\<forall>z \<in> \<omega>_limit_set x - range (flow0 y).
       infdist z (range (flow0 y)) \<ge> ?py / 2 ^ n)"
       using not_less by blast
     define A where "A = flow0 y ` UNIV"
     define B where "B = {z. infdist z (range (flow0 y)) \<ge> ?py / 2 ^ n}"
     have Ac:"closed A" unfolding A_def using y1 by auto
     have Bc:"closed B" unfolding B_def using infdist_closed by auto
     have "A \<inter> B = {}"
     proof (rule ccontr)
       assume "A \<inter> B \<noteq> {}"
       then obtain q where q: "q \<in> A" "q \<in> B" by blast
       have qz:"infdist q (range(flow0 y)) = 0" using q(1) unfolding A_def
         by simp
       note \<open>0 < ?py\<close>
       moreover have "2 ^ n > (0::real)" by auto
       ultimately have "infdist p (range (flow0 y)) / 2 ^ n > (0::real)"
         by simp
       then have qnz: "infdist q(range (flow0 y)) > 0" using q(2) unfolding B_def
         by auto
       show False using qz qnz by auto
     qed
     then have a1:"A \<inter> B \<inter> \<omega>_limit_set x = {}" by auto
     have "\<omega>_limit_set x - range(flow0 y) \<subseteq> B" using n B_def by blast
     then have a2:"\<omega>_limit_set x \<subseteq> A \<union> B" using A_def by auto
     from connected_closedD[OF wcon a1 a2 Ac Bc]
     have "A \<inter> \<omega>_limit_set x = {} \<or> B \<inter> \<omega>_limit_set x = {}" .
     moreover {
       assume "A \<inter> \<omega>_limit_set x = {}"
       then have False unfolding A_def using y(2) by blast
     }
     moreover {
       assume "B \<inter> \<omega>_limit_set x = {}"
       then have False unfolding B_def using p
         using A_def B_def a2 by blast
     }
     ultimately show False by blast
   qed
   then obtain s where s: "\<forall>n::nat. (s::nat \<Rightarrow> _) n \<in> \<omega>_limit_set x - flow0 y ` UNIV \<and>
                       infdist (s n) (flow0 y ` UNIV) < ?py/2^n"
     by metis
   then have "\<forall>n. s n \<in> \<omega>_limit_set x" by blast
   from seq_compactE[OF sc this]
   obtain l r where lr: "l \<in> \<omega>_limit_set x" "strict_mono r" "(s \<circ> r) \<longlonglongrightarrow> l" by blast
   have "\<And>n. infdist (s n) (range (flow0 y)) \<le> ?py / 2 ^ n" using s
     using less_eq_real_def by blast
   then have "\<And>n. norm(infdist (s n) (range (flow0 y))) \<le> ?py / 2 ^ n"
     by (auto simp add: infdist_nonneg)
   from LIMSEQ_norm_0_pow[OF \<open>0 < ?py\<close> _ this]
   have "((\<lambda>z. infdist z (flow0 y ` UNIV)) \<circ> s) \<longlonglongrightarrow> 0"
     by (auto simp add:o_def)
   from LIMSEQ_subseq_LIMSEQ[OF this lr(2)]
   have "((\<lambda>z. infdist z (flow0 y ` UNIV)) \<circ> (s \<circ> r)) \<longlonglongrightarrow> 0" by (simp add: o_assoc)
   moreover have "((\<lambda>z. infdist z (flow0 y ` UNIV)) \<circ> (s \<circ> r)) \<longlonglongrightarrow> infdist l (flow0 y ` UNIV)"
-    using continuous_on_sequentially lr(3) continuous_on_infdist
-    by blast
+    by (auto intro!: tendsto_eq_intros tendsto_compose_at[OF lr(3)])
   ultimately have "infdist l (flow0 y `UNIV) = 0" using LIMSEQ_unique by auto
   then have lu: "l \<in> flow0 y ` UNIV" using in_closed_iff_infdist_zero[OF y1 y2] by auto
   then have l1:"l \<in> X"
     using closed_orbit_global_existence periodic_orbit_def y(1) by auto
       (* TODO: factor out as periodic_orbitE *)
   have l2:"f l \<noteq> 0"
     by (smt \<open>l \<in> X\<close> \<open>l \<in> range (flow0 y)\<close> closed_orbit_global_existence fixed_point_imp_closed_orbit_period_zero(2) fixpoint_sol(2) image_iff local.flows_reverse periodic_orbit_def y(1))
   from transversal_segment_exists[OF l1 l2]
   obtain a b where ab: "transversal_segment a b" "l \<in> {a<--<b}" by blast
   then have "l \<in> \<omega>_limit_set x \<inter> {a<--<b}" using lr by auto
   from unique_transversal_segment_intersection[OF ab(1) ex_pos this]
   have luniq: "\<omega>_limit_set x \<inter> {a<--<b} = {l} " .
   from cross_time_continuous[OF ab, of 1]
   obtain d t where dt: "0 < d"
     "(\<And>y. y \<in> ball l d \<Longrightarrow> flow0 y (t y) \<in> {a<--<b})"
     "(\<And>y. y \<in> ball l d \<Longrightarrow> \<bar>t y\<bar> < 1)"
     "continuous_on (ball l d) t" "t l = 0"
     by auto
   obtain n where "(s \<circ> r) n \<in> ball l d" using lr(3) dt(1) unfolding LIMSEQ_iff_nz
     by (metis dist_commute mem_ball order_refl)
   then have "flow0 ((s \<circ> r) n) (t ((s \<circ> r) n )) \<in> {a<--<b}" using dt by auto
   moreover have sr: "(s \<circ> r) n \<in> \<omega>_limit_set x" "(s \<circ> r) n \<notin> flow0 y ` UNIV"
     using s by auto
   moreover have "flow0 ((s \<circ> r) n) (t ((s \<circ> r) n )) \<in> \<omega>_limit_set x"
     using \<open>invariant (\<omega>_limit_set x)\<close> calculation unfolding invariant_def trapped_def
     by (smt \<omega>_limit_set_in_compact_subset \<open>invariant (\<omega>_limit_set x)\<close> assms(1-4) invariant_def order_trans range_eqI subsetD trapped_iff_on_existence_ivl0 trapped_sol)
   ultimately have "flow0 ((s \<circ> r) n) (t ((s \<circ> r) n )) \<in> \<omega>_limit_set x \<inter> {a<--<b}" by auto
   from unique_transversal_segment_intersection[OF ab(1) ex_pos this]
   have "flow0 ((s \<circ> r) n) (t ((s \<circ> r) n )) = l" using luniq by auto
   then have "((s \<circ> r) n) = flow0 l (-(t ((s \<circ> r) n ))) "
     by (smt UNIV_I \<open>(s \<circ> r) n \<in> \<omega>_limit_set x\<close> flows_reverse \<omega>_limit_set_in_compact_existence assms(1-4)) 
   thus False using sr(2) lu
       \<open>flow0 ((s \<circ> r) n) (t ((s \<circ> r) n)) = l\<close> \<open>flow0 ((s \<circ> r) n) (t ((s \<circ> r) n)) \<in> \<omega>_limit_set x\<close>
       closed_orbit_global_existence image_iff local.flow_trans periodic_orbit_def \<omega>_limit_set_in_compact_existence range_eqI assms y(1)
     by smt
 qed
 
 end context c1_on_open_R2 begin
 
 lemma \<alpha>_limit_crossings:
   assumes "transversal_segment a b"
   assumes pos_ex: "{..0} \<subseteq> existence_ivl0 x"
   assumes "\<alpha>_limit_point x p"
   assumes "p \<in> {a<--<b}"
   obtains s where
     "s \<longlonglongrightarrow>\<^bsub>\<^esub> -\<infinity>"
     "(flow0 x \<circ> s) \<longlonglongrightarrow> p"
     "\<forall>\<^sub>F n in sequentially.
     flow0 x (s n) \<in> {a<--<b} \<and>
     s n \<in> existence_ivl0 x"
 proof -
   from pos_ex have "{0..} \<subseteq> uminus ` existence_ivl0 x" by force
   from rev.\<omega>_limit_crossings[unfolded rev_transversal_segment rev_existence_ivl_eq0 rev_eq_flow
       \<alpha>_limit_point_eq_rev[symmetric], OF assms(1) this assms(3,4)]
   obtain s where "filterlim s at_top sequentially" "((\<lambda>t. flow0 x (- t)) \<circ> s) \<longlonglongrightarrow> p"
     "\<forall>\<^sub>F n in sequentially. flow0 x (- s n) \<in> {a<--<b} \<and> s n \<in> uminus ` existence_ivl0 x" .
   then have "filterlim (-s) at_bot sequentially"
     "(flow0 x \<circ> (-s)) \<longlonglongrightarrow> p"
     "\<forall>\<^sub>F n in sequentially. flow0 x ((-s) n) \<in> {a<--<b} \<and> (-s) n \<in> existence_ivl0 x"
     by (auto simp: fun_Compl_def o_def filterlim_uminus_at_top)
   then show ?thesis ..
 qed
 
 text \<open>If a positive limit point has a regular point in its positive limit set then it is periodic\<close>
 lemma \<omega>_limit_point_\<omega>_limit_set_regular_imp_periodic:
   assumes "compact K" "K \<subseteq> X"
   assumes "x \<in> X" "trapped_forward x K"
   assumes y: "y \<in> \<omega>_limit_set x" "f y \<noteq> 0"
   assumes z: "z \<in> \<omega>_limit_set y \<union> \<alpha>_limit_set y" "f z \<noteq> 0"
   shows "periodic_orbit y \<and> flow0 y ` UNIV = \<omega>_limit_set x"
 proof -
   from trapped_sol_right[OF assms(1-4)] have ex_pos: "{0..} \<subseteq> existence_ivl0 x" by blast
   from \<omega>_limit_set_in_compact_existence[OF assms(1-4) y(1)]
   have yex: "existence_ivl0 y = UNIV" .
   from \<omega>_limit_set_invariant
   have "invariant (\<omega>_limit_set x)" .
   then have yinv: "flow0 y ` UNIV \<subseteq> \<omega>_limit_set x" using yex unfolding invariant_def
     using trapped_iff_on_existence_ivl0 y(1) by blast 
 
   have zy: "\<omega>_limit_point y z \<or> \<alpha>_limit_point y z"
     using z unfolding \<omega>_limit_set_def \<alpha>_limit_set_def by auto
 
   from \<omega>_limit_set_in_compact_\<omega>_limit_set_contained[OF assms(1-4)]
     \<omega>_limit_set_in_compact_\<alpha>_limit_set_contained[OF assms(1-4)]
   have zx:"z \<in> \<omega>_limit_set x" using zy y
     using z(1) by blast
   then have "z \<in> X"
     by (metis UNIV_I local.existence_ivl_initial_time_iff \<omega>_limit_set_in_compact_existence assms(1-4))
   from transversal_segment_exists[OF this z(2)]
   obtain a b where ab: "transversal_segment a b" "z \<in> {a<--<b}" by blast
 
   from zy
   obtain t1 t2 where t1: "flow0 y t1 \<in> {a<--<b}" and t2: "flow0 y t2 \<in> {a<--<b}" and "t1 \<noteq> t2"
   proof
     assume zy: "\<omega>_limit_point y z"
     from \<omega>_limit_crossings[OF ab(1) _ zy ab(2), unfolded yex]
     obtain s where s: "filterlim s at_top sequentially"
       "(flow0 y \<circ> s) \<longlonglongrightarrow> z"
       "\<forall>\<^sub>F n in sequentially. flow0 y (s n) \<in> {a<--<b}"
       by auto
     from eventually_happens[OF this(3)] obtain t1 where t1: "flow0 y t1 \<in> {a<--<b}" by auto
     have "\<forall>\<^sub>F n in sequentially. s n > t1"
       using filterlim_at_top_dense s(1) by auto
     with s(3) have "\<forall>\<^sub>F n in sequentially. flow0 y (s n) \<in> {a<--<b} \<and> s n > t1"
       by eventually_elim simp
     from eventually_happens[OF this] obtain t2 where t2: "flow0 y t2 \<in> {a<--<b}" and "t1 \<noteq> t2"
       by auto
     from t1 this show ?thesis ..
   next
     assume zy: "\<alpha>_limit_point y z"
     from \<alpha>_limit_crossings[OF ab(1) _ zy ab(2), unfolded yex]
     obtain s where s: "filterlim s at_bot sequentially"
       "(flow0 y \<circ> s) \<longlonglongrightarrow> z"
       "\<forall>\<^sub>F n in sequentially. flow0 y (s n) \<in> {a<--<b}"
       by auto
     from eventually_happens[OF this(3)] obtain t1 where t1: "flow0 y t1 \<in> {a<--<b}" by auto
     have "\<forall>\<^sub>F n in sequentially. s n < t1"
       using filterlim_at_bot_dense s(1) by auto
     with s(3) have "\<forall>\<^sub>F n in sequentially. flow0 y (s n) \<in> {a<--<b} \<and> s n < t1"
       by eventually_elim simp
     from eventually_happens[OF this] obtain t2 where t2: "flow0 y t2 \<in> {a<--<b}" and "t1 \<noteq> t2"
       by auto
     from t1 this show ?thesis ..
   qed
   have "flow0 y t1 \<in> \<omega>_limit_set x \<inter> {a<--<b}" using t1 UNIV_I yinv by auto
   moreover have "flow0 y t2 \<in> \<omega>_limit_set x \<inter> {a<--<b}" using t2 UNIV_I yinv by auto
   ultimately have feq:"flow0 y t1 = flow0 y t2"
     using unique_transversal_segment_intersection[OF \<open>transversal_segment a b\<close> ex_pos]
     by blast
   have "t1 \<noteq> t2" "t1 \<in> existence_ivl0 y" "t2 \<in> existence_ivl0 y" using \<open>t1 \<noteq>  t2\<close>
       apply blast
      apply (simp add: yex)
     by (simp add: yex)
   from periodic_orbitI[OF this feq y(2)]
   have 1: "periodic_orbit y" .
   from periodic_imp_\<omega>_limit_set[OF assms(1-4) this yinv]
   have 2: "flow0 y` UNIV = \<omega>_limit_set x" .
   show ?thesis using 1 2 by auto
 qed
 
 subsection \<open>Poincare Bendixson Theorems\<close>
 text \<open>Perko Section 3.7 Theorem 1\<close>
 theorem poincare_bendixson:
   assumes "compact K" "K \<subseteq> X"
   assumes "x \<in> X" "trapped_forward x K"
   assumes "0 \<notin> f ` (\<omega>_limit_set x)"
   obtains y where "periodic_orbit y"
     "flow0 y ` UNIV = \<omega>_limit_set x"
 proof -
   note f = \<open>0 \<notin> f ` (\<omega>_limit_set x)\<close>
   from \<omega>_limit_set_in_compact_nonempty[OF assms(1-4)]
   obtain y where y: "y \<in> \<omega>_limit_set x" by fastforce
   from \<omega>_limit_set_in_compact_existence[OF  assms(1-4) y]
   have yex: "existence_ivl0 y = UNIV" .
   from \<omega>_limit_set_invariant
   have "invariant (\<omega>_limit_set x)" .
   then have yinv: "flow0 y ` UNIV \<subseteq> \<omega>_limit_set x" using yex unfolding invariant_def
     using trapped_iff_on_existence_ivl0 y by blast
   from \<omega>_limit_set_in_compact_subset[OF assms(1-4)]
   have "\<omega>_limit_set x \<subseteq> K" .
   then have "flow0 y ` UNIV \<subseteq> K" using yinv by auto
   then have yk:"trapped_forward y K"
     by (simp add: image_subsetI range_subsetD trapped_forward_def)
   have "y \<in> X"
     by (simp add: local.mem_existence_ivl_iv_defined(2) yex)
 
   from \<omega>_limit_set_in_compact_nonempty[OF assms(1-2) this _]
   obtain z where z: "z \<in> \<omega>_limit_set y" using yk by blast
   from \<omega>_limit_set_in_compact_\<omega>_limit_set_contained[OF assms(1-4)]
   have zx:"z \<in> \<omega>_limit_set x" using \<open>z \<in> \<omega>_limit_set y\<close> y by auto
 
   have yreg : "f y \<noteq> 0" using f y
     by (metis rev_image_eqI)
   have zreg : "f z \<noteq> 0" using f zx
     by (metis rev_image_eqI) 
   from \<omega>_limit_point_\<omega>_limit_set_regular_imp_periodic[OF assms(1-4) y yreg _ zreg] z
   show ?thesis using that by blast
 qed
 
 lemma fixed_point_in_\<omega>_limit_set_imp_\<omega>_limit_set_singleton_fixed_point:
   assumes "compact K" "K \<subseteq> X"
   assumes "x \<in> X" "trapped_forward x K"
   assumes fp: "yfp \<in> \<omega>_limit_set x" "f yfp = 0"
   assumes zpx: "z \<in> \<omega>_limit_set x"
   assumes finite_fp: "finite {y \<in> K. f y = 0}" (is "finite ?S")
   shows "(\<exists>p1 \<in> \<omega>_limit_set x. f p1 = 0 \<and> \<omega>_limit_set z = {p1}) \<and>
     (\<exists>p2 \<in> \<omega>_limit_set x. f p2 = 0 \<and> \<alpha>_limit_set z = {p2})"
 proof -
   let ?weq = "{y \<in> \<omega>_limit_set x. f y = 0}"
   from \<omega>_limit_set_in_compact_subset[OF assms(1-4)]
   have wxK: "\<omega>_limit_set x \<subseteq> K" .
   from \<omega>_limit_set_in_compact_\<omega>_limit_set_contained[OF assms(1-4)]
   have zx: "\<omega>_limit_set z \<subseteq> \<omega>_limit_set x" using zpx by auto
   have zX: "z \<in> X" using subset_trans[OF wxK assms(2)]
     by (metis subset_iff zpx)
   from \<omega>_limit_set_in_compact_subset[OF assms(1-4)]
   have "?weq \<subseteq> ?S"
     by (smt Collect_mono_iff Int_iff inf.absorb_iff1)
   then have "finite ?weq" using \<open>finite ?S\<close>
     by (blast intro: rev_finite_subset) 
 
   consider "f z = 0" | "f z \<noteq> 0" by auto
   then show ?thesis
   proof cases
     assume "f z = 0"
     from fixed_point_imp_\<omega>_limit_set[OF zX this]
       fixed_point_imp_\<alpha>_limit_set[OF zX this]
     show ?thesis
       by (metis (mono_tags) \<open>f z = 0\<close> zpx)
   next
     assume "f z \<noteq> 0"
     have zweq: "\<omega>_limit_set z \<subseteq> ?weq"
       apply clarsimp
     proof (rule ccontr)
       fix k assume k: "k \<in> \<omega>_limit_set z" "\<not> (k \<in> \<omega>_limit_set x \<and> f k = 0)"
       then have "f k \<noteq> 0" using zx k by auto
       from \<omega>_limit_point_\<omega>_limit_set_regular_imp_periodic[OF assms(1-4) zpx \<open>f z \<noteq> 0\<close> _ this] k(1)
       have "periodic_orbit z" "range(flow0 z) = \<omega>_limit_set x" by auto
       then have "0 \<notin> f ` (\<omega>_limit_set x)"
         by (metis image_iff periodic_orbit_imp_flow0_regular)
       thus False using fp
         by (metis (mono_tags, lifting) empty_Collect_eq image_eqI)
     qed
     have zweq0: "\<alpha>_limit_set z \<subseteq> ?weq"
       apply clarsimp
     proof (rule ccontr)
       fix k assume k: "k \<in> \<alpha>_limit_set z" "\<not> (k \<in> \<omega>_limit_set x \<and> f k = 0)"
       then have "f k \<noteq> 0" using zx k
           \<omega>_limit_set_in_compact_\<alpha>_limit_set_contained[OF assms(1-4), of z] zpx
         by auto
       from \<omega>_limit_point_\<omega>_limit_set_regular_imp_periodic[OF assms(1-4) zpx \<open>f z \<noteq> 0\<close> _ this] k(1)
       have "periodic_orbit z" "range(flow0 z) = \<omega>_limit_set x" by auto
       then have "0 \<notin> f ` (\<omega>_limit_set x)"
         by (metis image_iff periodic_orbit_imp_flow0_regular)
       thus False using fp
         by (metis (mono_tags, lifting) empty_Collect_eq image_eqI)
     qed
     from \<omega>_limit_set_in_compact_existence[OF assms(1-4) zpx]
     have zex: "existence_ivl0 z = UNIV" .
     from \<omega>_limit_set_invariant
     have "invariant (\<omega>_limit_set x)" .
     then have zinv: "flow0 z ` UNIV \<subseteq> \<omega>_limit_set x" using zex unfolding invariant_def
       using trapped_iff_on_existence_ivl0 zpx by blast
     then have "flow0 z ` UNIV \<subseteq> K" using wxK by auto
     then have a2: "trapped_forward z K" "trapped_backward z K"
       using trapped_def trapped_iff_on_existence_ivl0 apply fastforce
       using \<open>range (flow0 z) \<subseteq> K\<close> trapped_def trapped_iff_on_existence_ivl0 by blast
     have a3: "finite (\<omega>_limit_set z)"
       by (metis \<open>finite ?weq\<close> finite_subset zweq)
     from finite_\<omega>_limit_set_in_compact_imp_unique_fixed_point[OF assms(1-2) zX a2(1) a3]
     obtain p1 where p1: "\<omega>_limit_set z = {p1}" "f p1 = 0" by blast
     then have "p1 \<in> ?weq" using zweq by blast
     moreover
     have "finite (\<alpha>_limit_set z)"
       by (metis \<open>finite ?weq\<close> finite_subset zweq0)
     from finite_\<alpha>_limit_set_in_compact_imp_unique_fixed_point[OF assms(1-2) zX a2(2) this]
     obtain p2 where p2: "\<alpha>_limit_set z = {p2}" "f p2 = 0" by blast
     then have "p2 \<in> ?weq" using zweq0 by blast
     ultimately show ?thesis
       by (simp add: p1 p2)
   qed
 qed
 
 end context c1_on_open_R2 begin
 
 text \<open>Perko Section 3.7 Theorem 2\<close>
 theorem poincare_bendixson_general:
   assumes "compact K" "K \<subseteq> X"
   assumes "x \<in> X" "trapped_forward x K"
   assumes "S = {y \<in> K. f y = 0}" "finite S"
   shows
     "(\<exists>y \<in> S. \<omega>_limit_set x = {y}) \<or>
   (\<exists>y. periodic_orbit y \<and>
     flow0 y ` UNIV = \<omega>_limit_set x) \<or>
   (\<exists>P R. \<omega>_limit_set x = P \<union> R \<and>
     P \<subseteq> S \<and> 0 \<notin> f ` R \<and> R \<noteq> {} \<and>
     (\<forall>z \<in> R.
       (\<exists>p1 \<in> P. \<omega>_limit_set z = {p1}) \<and>
       (\<exists>p2 \<in> P. \<alpha>_limit_set z = {p2})))"
 proof -
   note S = \<open>S = {y \<in> K. f y = 0}\<close>
   let ?wreg = "{y \<in> \<omega>_limit_set x. f y \<noteq> 0}"
   let ?weq = "{y \<in> \<omega>_limit_set x. f y = 0}"
   have wreqweq: "?wreg \<union> ?weq = \<omega>_limit_set x"
     by (smt Collect_cong Collect_disj_eq mem_Collect_eq \<omega>_limit_set_def)
 
   from trapped_sol_right[OF assms(1-4)] have ex_pos: "{0..} \<subseteq> existence_ivl0 x" by blast
   from \<omega>_limit_set_in_compact_subset[OF assms(1-4)]
   have wxK: "\<omega>_limit_set x \<subseteq> K" .
   then have "?weq \<subseteq> S" using S
     by (smt Collect_mono_iff Int_iff inf.absorb_iff1)
   then have "finite ?weq" using \<open>finite S\<close>
     by (metis rev_finite_subset) 
   from \<omega>_limit_set_invariant
   have xinv: "invariant (\<omega>_limit_set x)" .
 
   from \<omega>_limit_set_in_compact_nonempty[OF assms(1-4)] wreqweq
   consider "?wreg = {}" |
     "?weq = {}" |
     "?weq \<noteq> {}" "?wreg \<noteq> {}" by auto
   then show ?thesis
   proof cases
     (* If w has no regular points then it is equal to a single unique fixed point *)
     assume "?wreg = {}"
     then have "finite (\<omega>_limit_set x)"
       by (metis (mono_tags, lifting) \<open>{y \<in> \<omega>_limit_set x. f y = 0} \<subseteq> S\<close> \<open>finite S\<close> rev_finite_subset sup_bot.left_neutral wreqweq)
     from finite_\<omega>_limit_set_in_compact_imp_unique_fixed_point[OF assms(1-4) this]
     obtain y where y: "\<omega>_limit_set x = {y}" "f y = 0" by blast
     then have "y \<in> S"
       by (metis Un_empty_left \<open>?weq \<subseteq> S\<close> \<open>?wreg = {}\<close> insert_subset wreqweq)
     then show ?thesis using y by auto
   next
     (* If w has no fixed points, then the Poincare Bendixson theorem applies *)
     assume "?weq = {}"
     then have " 0 \<notin> f ` \<omega>_limit_set x"
       by (smt empty_Collect_eq imageE)
     from poincare_bendixson[OF assms(1-4) this]
     have "(\<exists>y. periodic_orbit y \<and> flow0 y ` UNIV = \<omega>_limit_set x)"
       by metis
     then show ?thesis by blast
   next
     (* Otherwise, all points in the limit set converge to a finite subset of the fixed points *)
     assume "?weq \<noteq> {}" "?wreg \<noteq> {}"
     then obtain yfp where yfp: "yfp \<in> \<omega>_limit_set x" "f yfp = 0" by auto
     have "0 \<notin> f ` ?wreg" by auto
     have "(\<exists>p1\<in>\<omega>_limit_set x. f p1 = 0 \<and> \<omega>_limit_set z = {p1}) \<and>
       (\<exists>p2\<in>\<omega>_limit_set x. f p2 = 0 \<and> \<alpha>_limit_set z = {p2})"
       if zpx: "z \<in> \<omega>_limit_set x" for z
       using fixed_point_in_\<omega>_limit_set_imp_\<omega>_limit_set_singleton_fixed_point[
           OF assms(1-4) yfp zpx \<open>finite S\<close>[unfolded S]] by auto
     then have "\<omega>_limit_set x = ?weq \<union> ?wreg \<and>
         ?weq \<subseteq> S \<and> 0 \<notin> f ` ?wreg \<and> ?wreg \<noteq> {} \<and>
         (\<forall>z \<in> ?wreg.
          (\<exists>p1 \<in> ?weq. \<omega>_limit_set z = {p1}) \<and>
          (\<exists>p2 \<in> ?weq. \<alpha>_limit_set z = {p2}))"
       using wreqweq \<open>?weq \<subseteq> S\<close> \<open>?wreg \<noteq> {}\<close> \<open>0 \<notin> f ` ?wreg\<close>
       by blast
     then show ?thesis by blast
   qed
 qed
 
 corollary poincare_bendixson_applied:
   assumes "compact K" "K \<subseteq> X"
   assumes "K \<noteq> {}" "positively_invariant K"
   assumes "0 \<notin> f ` K"
   obtains y where "periodic_orbit y" "flow0 y ` UNIV \<subseteq> K"
 proof -
   from assms(1-4) obtain x where "x \<in> K" "x \<in> X" by auto
   have *: "trapped_forward x K"
     using assms(4) \<open>x \<in> K\<close>
     by (auto simp: positively_invariant_def)
   have subs: "\<omega>_limit_set x \<subseteq> K"
     by (rule \<omega>_limit_set_in_compact_subset[OF assms(1-2) \<open>x \<in> X\<close> *])
   with assms(5) have "0 \<notin> f ` \<omega>_limit_set x" by auto
   from poincare_bendixson[OF assms(1-2) \<open>x \<in> X\<close> * this]
   obtain y where "periodic_orbit y" "range (flow0 y) = \<omega>_limit_set x"
     by force
   then have "periodic_orbit y" "flow0 y ` UNIV \<subseteq> K" using subs by auto
   then show ?thesis ..
 qed
 
 (*
   Limit cycles are periodic orbits that is the \<omega> (or \<alpha>)-limit set of some point not in the cycle.
   As with periodic_orbit, limit_cycles are defined for a representative point y
 *)
 definition "limit_cycle y \<longleftrightarrow>
   periodic_orbit y \<and>
   (\<exists>x. x \<notin> flow0 y ` UNIV \<and>
   (flow0 y ` UNIV = \<omega>_limit_set x \<or> flow0 y ` UNIV = \<alpha>_limit_set x))"
 
 corollary poincare_bendixson_limit_cycle:
   assumes "compact K" "K \<subseteq> X"
   assumes "x \<in> K" "positively_invariant K"
   assumes "0 \<notin> f ` K"
   assumes "rev.flow0 x t \<notin> K"
   obtains y where "limit_cycle y" "flow0 y ` UNIV \<subseteq> K"
 proof -
   have "x \<in> X" using assms(2-3) by blast
   have *: "trapped_forward x K"
     using assms(3-4)
     by (auto simp: positively_invariant_def)
   have subs: "\<omega>_limit_set x \<subseteq> K"
     by (rule \<omega>_limit_set_in_compact_subset[OF assms(1-2) \<open>x \<in> X\<close> *])
   with assms(5) have "0 \<notin> f ` \<omega>_limit_set x" by auto
   from poincare_bendixson[OF assms(1-2) \<open>x \<in> X\<close> * this]
   obtain y where y: "periodic_orbit y" "range (flow0 y) = \<omega>_limit_set x"
     by force
   then have c2: "flow0 y ` UNIV \<subseteq> K" using subs by auto
   have exy: "existence_ivl0 y = UNIV"
     using closed_orbit_global_existence periodic_orbit_def y(1) by blast
   have "x \<notin> flow0 y ` UNIV"
   proof clarsimp
     fix tt
     assume "x = flow0 y tt"
     then have "rev.flow0 (flow0 y tt) t \<notin> K" using assms(6) by auto
     moreover have "rev.flow0 (flow0 y tt) t \<in> flow0 y ` UNIV" using exy unfolding rev_eq_flow
       using UNIV_I \<open>x = flow0 y tt\<close> closed_orbit_\<omega>_limit_set closed_orbit_flow0 periodic_orbit_def y by auto
     ultimately show False using c2 by blast
   qed
   then have "limit_cycle y" "flow0 y ` UNIV \<subseteq> K" using y c2 unfolding limit_cycle_def by auto
   then show ?thesis ..
 qed
 
 end
 
 end