[STATEMENT]
lemma one_odd:
  fixes b n :: nat
  assumes "b>2"
  shows "(\<alpha> b n) mod 2 = 1 \<or> (\<alpha> b (n+1)) mod 2 = 1"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<alpha> b n mod 2 = 1 \<or> \<alpha> b (n + 1) mod 2 = 1
[PROOF STEP]
proof(rule ccontr)
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<not> (\<alpha> b n mod 2 = 1 \<or> \<alpha> b (n + 1) mod 2 = 1) \<Longrightarrow> False
[PROOF STEP]
assume asm: "\<not>(\<alpha> b n mod 2 = 1 \<or> \<alpha> b (n + 1) mod 2 = 1)"
[PROOF STATE]
proof (state)
this:
\<not> (\<alpha> b n mod 2 = 1 \<or> \<alpha> b (n + 1) mod 2 = 1)

goal (1 subgoal):
 1. \<not> (\<alpha> b n mod 2 = 1 \<or> \<alpha> b (n + 1) mod 2 = 1) \<Longrightarrow> False
[PROOF STEP]
from asm
[PROOF STATE]
proof (chain)
picking this:
\<not> (\<alpha> b n mod 2 = 1 \<or> \<alpha> b (n + 1) mod 2 = 1)
[PROOF STEP]
have step1: "(\<alpha> b n mod 2 = 0 \<and> \<alpha> b (n + 1) mod 2 = 0)"
[PROOF STATE]
proof (prove)
using this:
\<not> (\<alpha> b n mod 2 = 1 \<or> \<alpha> b (n + 1) mod 2 = 1)

goal (1 subgoal):
 1. \<alpha> b n mod 2 = 0 \<and> \<alpha> b (n + 1) mod 2 = 0
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
\<alpha> b n mod 2 = 0 \<and> \<alpha> b (n + 1) mod 2 = 0

goal (1 subgoal):
 1. \<not> (\<alpha> b n mod 2 = 1 \<or> \<alpha> b (n + 1) mod 2 = 1) \<Longrightarrow> False
[PROOF STEP]
from step1
[PROOF STATE]
proof (chain)
picking this:
\<alpha> b n mod 2 = 0 \<and> \<alpha> b (n + 1) mod 2 = 0
[PROOF STEP]
have s1: "(\<alpha> b n)^2 mod 2 = 0 \<and> (\<alpha> b (n+1))^2 mod 2 = 0"
[PROOF STATE]
proof (prove)
using this:
\<alpha> b n mod 2 = 0 \<and> \<alpha> b (n + 1) mod 2 = 0

goal (1 subgoal):
 1. (\<alpha> b n)\<^sup>2 mod 2 = 0 \<and> (\<alpha> b (n + 1))\<^sup>2 mod 2 = 0
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
(\<alpha> b n)\<^sup>2 mod 2 = 0 \<and> (\<alpha> b (n + 1))\<^sup>2 mod 2 = 0

goal (1 subgoal):
 1. \<not> (\<alpha> b n mod 2 = 1 \<or> \<alpha> b (n + 1) mod 2 = 1) \<Longrightarrow> False
[PROOF STEP]
from step1
[PROOF STATE]
proof (chain)
picking this:
\<alpha> b n mod 2 = 0 \<and> \<alpha> b (n + 1) mod 2 = 0
[PROOF STEP]
have s2: "(int b)*(\<alpha> b n)*(\<alpha> b (n+1)) mod 2 = 0"
[PROOF STATE]
proof (prove)
using this:
\<alpha> b n mod 2 = 0 \<and> \<alpha> b (n + 1) mod 2 = 0

goal (1 subgoal):
 1. int b * \<alpha> b n * \<alpha> b (n + 1) mod 2 = 0
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
int b * \<alpha> b n * \<alpha> b (n + 1) mod 2 = 0

goal (1 subgoal):
 1. \<not> (\<alpha> b n mod 2 = 1 \<or> \<alpha> b (n + 1) mod 2 = 1) \<Longrightarrow> False
[PROOF STEP]
from s1
[PROOF STATE]
proof (chain)
picking this:
(\<alpha> b n)\<^sup>2 mod 2 = 0 \<and> (\<alpha> b (n + 1))\<^sup>2 mod 2 = 0
[PROOF STEP]
have s3: "((\<alpha> b (n+1))^2 + (\<alpha> b n)^2) mod 2 = 0"
[PROOF STATE]
proof (prove)
using this:
(\<alpha> b n)\<^sup>2 mod 2 = 0 \<and> (\<alpha> b (n + 1))\<^sup>2 mod 2 = 0

goal (1 subgoal):
 1. ((\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2) mod 2 = 0
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
((\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2) mod 2 = 0

goal (1 subgoal):
 1. \<not> (\<alpha> b n mod 2 = 1 \<or> \<alpha> b (n + 1) mod 2 = 1) \<Longrightarrow> False
[PROOF STEP]
from s2 s3 add_mod
[PROOF STATE]
proof (chain)
picking this:
int b * \<alpha> b n * \<alpha> b (n + 1) mod 2 = 0
((\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2) mod 2 = 0
\<lbrakk>?p mod 2 = 0; ?q mod 2 = 0\<rbrakk> \<Longrightarrow> (?p + ?q) mod 2 = 0 \<and> (?p - ?q) mod 2 = 0
[PROOF STEP]
have s4: "((\<alpha> b (n+1))^2 + (\<alpha> b n)^2 - (int b)*((\<alpha> b n)*(\<alpha> b (n+1)))) mod 2 = 0"
[PROOF STATE]
proof (prove)
using this:
int b * \<alpha> b n * \<alpha> b (n + 1) mod 2 = 0
((\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2) mod 2 = 0
\<lbrakk>?p mod 2 = 0; ?q mod 2 = 0\<rbrakk> \<Longrightarrow> (?p + ?q) mod 2 = 0 \<and> (?p - ?q) mod 2 = 0

goal (1 subgoal):
 1. ((\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 - int b * (\<alpha> b n * \<alpha> b (n + 1))) mod 2 = 0
[PROOF STEP]
by (simp add: Groups.mult_ac(2) Groups.mult_ac(3))
[PROOF STATE]
proof (state)
this:
((\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 - int b * (\<alpha> b n * \<alpha> b (n + 1))) mod 2 = 0

goal (1 subgoal):
 1. \<not> (\<alpha> b n mod 2 = 1 \<or> \<alpha> b (n + 1) mod 2 = 1) \<Longrightarrow> False
[PROOF STEP]
have s5: "(\<alpha> b (n+1))^2+(\<alpha> b n)^2-(int b)*((\<alpha> b n)*(\<alpha> b (n+1)))=(\<alpha> b (n+1))^2-(int b)*(\<alpha> b (n+1)*(\<alpha> b n))+(\<alpha> b n)^2"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 - int b * (\<alpha> b n * \<alpha> b (n + 1)) = (\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) + (\<alpha> b n)\<^sup>2
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
(\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 - int b * (\<alpha> b n * \<alpha> b (n + 1)) = (\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) + (\<alpha> b n)\<^sup>2

goal (1 subgoal):
 1. \<not> (\<alpha> b n mod 2 = 1 \<or> \<alpha> b (n + 1) mod 2 = 1) \<Longrightarrow> False
[PROOF STEP]
from s4 s5
[PROOF STATE]
proof (chain)
picking this:
((\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 - int b * (\<alpha> b n * \<alpha> b (n + 1))) mod 2 = 0
(\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 - int b * (\<alpha> b n * \<alpha> b (n + 1)) = (\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) + (\<alpha> b n)\<^sup>2
[PROOF STEP]
have s6: "((\<alpha> b (n+1))^2-(int b)*(\<alpha> b (n+1)*(\<alpha> b n))+(\<alpha> b n)^2) mod 2 = 0"
[PROOF STATE]
proof (prove)
using this:
((\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 - int b * (\<alpha> b n * \<alpha> b (n + 1))) mod 2 = 0
(\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 - int b * (\<alpha> b n * \<alpha> b (n + 1)) = (\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) + (\<alpha> b n)\<^sup>2

goal (1 subgoal):
 1. ((\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) + (\<alpha> b n)\<^sup>2) mod 2 = 0
[PROOF STEP]
proof -
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<lbrakk>((\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 - int b * (\<alpha> b n * \<alpha> b (n + 1))) mod 2 = 0; (\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 - int b * (\<alpha> b n * \<alpha> b (n + 1)) = (\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) + (\<alpha> b n)\<^sup>2\<rbrakk> \<Longrightarrow> ((\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) + (\<alpha> b n)\<^sup>2) mod 2 = 0
[PROOF STEP]
have f1: "(\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) = (\<alpha> b (n + 1))\<^sup>2 + - 1 * (int b * (\<alpha> b (n + 1) * \<alpha> b n))"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) = (\<alpha> b (n + 1))\<^sup>2 + - 1 * (int b * (\<alpha> b (n + 1) * \<alpha> b n))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
(\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) = (\<alpha> b (n + 1))\<^sup>2 + - 1 * (int b * (\<alpha> b (n + 1) * \<alpha> b n))

goal (1 subgoal):
 1. \<lbrakk>((\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 - int b * (\<alpha> b n * \<alpha> b (n + 1))) mod 2 = 0; (\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 - int b * (\<alpha> b n * \<alpha> b (n + 1)) = (\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) + (\<alpha> b n)\<^sup>2\<rbrakk> \<Longrightarrow> ((\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) + (\<alpha> b n)\<^sup>2) mod 2 = 0
[PROOF STEP]
have f2: "(\<alpha> b (n + 1))\<^sup>2 + - 1 * (int b * (\<alpha> b (n + 1) * \<alpha> b n)) + (\<alpha> b n)\<^sup>2 = (\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 + - 1 * (int b * (\<alpha> b n * \<alpha> b (n + 1)))"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (\<alpha> b (n + 1))\<^sup>2 + - 1 * (int b * (\<alpha> b (n + 1) * \<alpha> b n)) + (\<alpha> b n)\<^sup>2 = (\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 + - 1 * (int b * (\<alpha> b n * \<alpha> b (n + 1)))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
(\<alpha> b (n + 1))\<^sup>2 + - 1 * (int b * (\<alpha> b (n + 1) * \<alpha> b n)) + (\<alpha> b n)\<^sup>2 = (\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 + - 1 * (int b * (\<alpha> b n * \<alpha> b (n + 1)))

goal (1 subgoal):
 1. \<lbrakk>((\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 - int b * (\<alpha> b n * \<alpha> b (n + 1))) mod 2 = 0; (\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 - int b * (\<alpha> b n * \<alpha> b (n + 1)) = (\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) + (\<alpha> b n)\<^sup>2\<rbrakk> \<Longrightarrow> ((\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) + (\<alpha> b n)\<^sup>2) mod 2 = 0
[PROOF STEP]
have "((\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 + - 1 * (int b * (\<alpha> b n * \<alpha> b (n + 1)))) mod 2 = 0"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. ((\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 + - 1 * (int b * (\<alpha> b n * \<alpha> b (n + 1)))) mod 2 = 0
[PROOF STEP]
using s4
[PROOF STATE]
proof (prove)
using this:
((\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 - int b * (\<alpha> b n * \<alpha> b (n + 1))) mod 2 = 0

goal (1 subgoal):
 1. ((\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 + - 1 * (int b * (\<alpha> b n * \<alpha> b (n + 1)))) mod 2 = 0
[PROOF STEP]
by fastforce
[PROOF STATE]
proof (state)
this:
((\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 + - 1 * (int b * (\<alpha> b n * \<alpha> b (n + 1)))) mod 2 = 0

goal (1 subgoal):
 1. \<lbrakk>((\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 - int b * (\<alpha> b n * \<alpha> b (n + 1))) mod 2 = 0; (\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 - int b * (\<alpha> b n * \<alpha> b (n + 1)) = (\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) + (\<alpha> b n)\<^sup>2\<rbrakk> \<Longrightarrow> ((\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) + (\<alpha> b n)\<^sup>2) mod 2 = 0
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
((\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 + - 1 * (int b * (\<alpha> b n * \<alpha> b (n + 1)))) mod 2 = 0

goal (1 subgoal):
 1. ((\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) + (\<alpha> b n)\<^sup>2) mod 2 = 0
[PROOF STEP]
using f2 f1
[PROOF STATE]
proof (prove)
using this:
((\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 + - 1 * (int b * (\<alpha> b n * \<alpha> b (n + 1)))) mod 2 = 0
(\<alpha> b (n + 1))\<^sup>2 + - 1 * (int b * (\<alpha> b (n + 1) * \<alpha> b n)) + (\<alpha> b n)\<^sup>2 = (\<alpha> b (n + 1))\<^sup>2 + (\<alpha> b n)\<^sup>2 + - 1 * (int b * (\<alpha> b n * \<alpha> b (n + 1)))
(\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) = (\<alpha> b (n + 1))\<^sup>2 + - 1 * (int b * (\<alpha> b (n + 1) * \<alpha> b n))

goal (1 subgoal):
 1. ((\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) + (\<alpha> b n)\<^sup>2) mod 2 = 0
[PROOF STEP]
by presburger
[PROOF STATE]
proof (state)
this:
((\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) + (\<alpha> b n)\<^sup>2) mod 2 = 0

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
((\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) + (\<alpha> b n)\<^sup>2) mod 2 = 0

goal (1 subgoal):
 1. \<not> (\<alpha> b n mod 2 = 1 \<or> \<alpha> b (n + 1) mod 2 = 1) \<Longrightarrow> False
[PROOF STEP]
from s6 alpha_det1
[PROOF STATE]
proof (chain)
picking this:
((\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) + (\<alpha> b n)\<^sup>2) mod 2 = 0
2 < ?b \<Longrightarrow> (\<alpha> ?b (Suc ?n))\<^sup>2 - int ?b * \<alpha> ?b (Suc ?n) * \<alpha> ?b ?n + (\<alpha> ?b ?n)\<^sup>2 = 1
[PROOF STEP]
show False
[PROOF STATE]
proof (prove)
using this:
((\<alpha> b (n + 1))\<^sup>2 - int b * (\<alpha> b (n + 1) * \<alpha> b n) + (\<alpha> b n)\<^sup>2) mod 2 = 0
2 < ?b \<Longrightarrow> (\<alpha> ?b (Suc ?n))\<^sup>2 - int ?b * \<alpha> ?b (Suc ?n) * \<alpha> ?b ?n + (\<alpha> ?b ?n)\<^sup>2 = 1

goal (1 subgoal):
 1. False
[PROOF STEP]
by (simp add: assms mult.assoc)
[PROOF STATE]
proof (state)
this:
False

goal:
No subgoals!
[PROOF STEP]
qed


[STATEMENT]
lemma infs_mono_strong: "stream_all2 (\<lambda> a b. P a \<longrightarrow> Q b) u v \<Longrightarrow> infs P u \<Longrightarrow> infs Q v"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<lbrakk>stream_all2 (\<lambda>a b. P a \<longrightarrow> Q b) u v; infs P u\<rbrakk> \<Longrightarrow> infs Q v
[PROOF STEP]
unfolding stream_rel_snth infs_snth
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<lbrakk>\<forall>i. P (u !! i) \<longrightarrow> Q (v !! i); \<forall>n. \<exists>k\<ge>n. P (u !! k)\<rbrakk> \<Longrightarrow> \<forall>n. \<exists>k\<ge>n. Q (v !! k)
[PROOF STEP]
by blast


[STATEMENT]
lemma path_comp: "\<lbrakk> walk xs; walk ys; xs = Nil \<or> ys = Nil \<or> last xs\<rightarrow>hd ys; distinct (xs @ ys) \<rbrakk>
  \<Longrightarrow> path (xs @ ys)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<lbrakk>walk xs; walk ys; xs = [] \<or> ys = [] \<or> last xs \<rightarrow> hd ys; distinct (xs @ ys)\<rbrakk> \<Longrightarrow> path (xs @ ys)
[PROOF STEP]
using walk_comp
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>walk ?xs; walk ?ys; ?xs = [] \<or> ?ys = [] \<or> last ?xs \<rightarrow> hd ?ys\<rbrakk> \<Longrightarrow> walk (?xs @ ?ys)

goal (1 subgoal):
 1. \<lbrakk>walk xs; walk ys; xs = [] \<or> ys = [] \<or> last xs \<rightarrow> hd ys; distinct (xs @ ys)\<rbrakk> \<Longrightarrow> path (xs @ ys)
[PROOF STEP]
by blast


[STATEMENT]
lemma Example2_lemma2_Suc0: "\<lbrakk>j<n; b j=0\<rbrakk> \<Longrightarrow>
 Suc (\<Sum>i::nat=0..< n. b i)=(\<Sum>i=0..< n. (b (j:=Suc 0)) i)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<lbrakk>j < n; b j = 0\<rbrakk> \<Longrightarrow> Suc (sum b {0..<n}) = sum (b(j := Suc 0)) {0..<n}
[PROOF STEP]
by(simp add:Example2_lemma2)


[STATEMENT]
lemma continuous_on_cblinfun_matrix:
  fixes f::"'a::t2_space \<Rightarrow> 'b::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L 'c::complex_inner"
  assumes "continuous_on S f"
  shows "continuous_on S (\<lambda>x. (f x) j \<bullet>\<^sub>C i)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. continuous_on S (\<lambda>x. cblinfun_apply (f x) j \<bullet>\<^sub>C i)
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
continuous_on S f

goal (1 subgoal):
 1. continuous_on S (\<lambda>x. cblinfun_apply (f x) j \<bullet>\<^sub>C i)
[PROOF STEP]
by (auto simp: continuous_on_eq_continuous_within continuous_cblinfun_matrix)


[STATEMENT]
lemma independentD: "independent s \<Longrightarrow> finite t \<Longrightarrow> t \<subseteq> s \<Longrightarrow> (\<Sum>v\<in>t. u v *s v) = 0 \<Longrightarrow> v \<in> t \<Longrightarrow> u v = 0"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<lbrakk>independent s; finite t; t \<subseteq> s; (\<Sum>v\<in>t. u v *s v) = (0::'b); v \<in> t\<rbrakk> \<Longrightarrow> u v = (0::'a)
[PROOF STEP]
by (simp add: independent_explicit_module)


[STATEMENT]
lemma RDirProd_iso2:
  "(\<lambda>(x, (y, z)). ((x, y), z)) \<in> ring_iso (RDirProd R (RDirProd S T)) (RDirProd (RDirProd R S) T)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (\<lambda>(x, y, z). ((x, y), z)) \<in> ring_iso (RDirProd R (RDirProd S T)) (RDirProd (RDirProd R S) T)
[PROOF STEP]
unfolding ring_iso_def ring_hom_def bij_betw_def inj_on_def
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (\<lambda>(x, y, z). ((x, y), z)) \<in> {h \<in> {h \<in> carrier (RDirProd R (RDirProd S T)) \<rightarrow> carrier (RDirProd (RDirProd R S) T). (\<forall>x y. x \<in> carrier (RDirProd R (RDirProd S T)) \<and> y \<in> carrier (RDirProd R (RDirProd S T)) \<longrightarrow> h (x \<otimes>\<^bsub>RDirProd R (RDirProd S T)\<^esub> y) = h x \<otimes>\<^bsub>RDirProd (RDirProd R S) T\<^esub> h y \<and> h (x \<oplus>\<^bsub>RDirProd R (RDirProd S T)\<^esub> y) = h x \<oplus>\<^bsub>RDirProd (RDirProd R S) T\<^esub> h y) \<and> h \<one>\<^bsub>RDirProd R (RDirProd S T)\<^esub> = \<one>\<^bsub>RDirProd (RDirProd R S) T\<^esub>}. (\<forall>x\<in>carrier (RDirProd R (RDirProd S T)). \<forall>y\<in>carrier (RDirProd R (RDirProd S T)). h x = h y \<longrightarrow> x = y) \<and> h ` carrier (RDirProd R (RDirProd S T)) = carrier (RDirProd (RDirProd R S) T)}
[PROOF STEP]
by (auto simp add: image_iff RDirProd_def DirProd_def monoid.defs)


[STATEMENT]
lemma less_sets_imp_disjnt: "A \<lless> B \<Longrightarrow> disjnt A B"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. A \<lless> B \<Longrightarrow> disjnt A B
[PROOF STEP]
by (auto simp: less_sets_def disjnt_def)


[STATEMENT]
lemma [simp]: "Disjunctive_fun (r::('c \<Rightarrow> 'a::complete_lattice \<Rightarrow> 'b::complete_lattice))
        \<Longrightarrow> mono_fun r"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. Disjunctive_fun r \<Longrightarrow> mono_fun r
[PROOF STEP]
by (simp add: Disjunctive_fun_def mono_fun_def)


[STATEMENT]
lemma weight_sample_uniform_0 [simp]: "weight_spmf (sample_uniform 0) = 0"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. weight_spmf (sample_uniform 0) = 0
[PROOF STEP]
by(auto simp add: weight_sample_uniform indicator_def)


[STATEMENT]
lemma inner_eucl_of_list:
  fixes i::"'a::executable_euclidean_space"
  assumes i: "i \<in> Basis"
  assumes l: "length xs = DIM('a)"
  shows "i \<bullet> eucl_of_list xs = xs ! (index Basis_list i)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. i \<bullet> eucl_of_list xs = xs ! index Basis_list i
[PROOF STEP]
using eucl_of_list_inner[OF assms]
[PROOF STATE]
proof (prove)
using this:
eucl_of_list xs \<bullet> i = xs ! index Basis_list i

goal (1 subgoal):
 1. i \<bullet> eucl_of_list xs = xs ! index Basis_list i
[PROOF STEP]
by (auto simp: inner_commute)


[STATEMENT]
lemma nonempty_has_size: "(S \<noteq> {#}) = (0 < size S)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (S \<noteq> {#}) = (0 < size S)
[PROOF STEP]
by (metis gr0I gr_implies_not0 size_empty size_eq_0_iff_empty)


[STATEMENT]
lemma homeomorphism_UNIV_imp_open_map:
  "homeomorphism UNIV UNIV p p' \<Longrightarrow> open f' \<Longrightarrow> open (p ` f')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<lbrakk>homeomorphism UNIV UNIV p p'; open f'\<rbrakk> \<Longrightarrow> open (p ` f')
[PROOF STEP]
by (auto dest: homeomorphism_imp_open_map[where U=f'])


[STATEMENT]
lemma nbt_subset_imp_card_leq:
  assumes "x \<in> carrier" and "y \<in> carrier"
  shows "no_better_than x carrier relation \<subseteq> no_better_than y carrier relation \<longleftrightarrow>
  card (no_better_than x carrier relation) \<le> card  (no_better_than y carrier relation)"
  (is "?nbt \<longleftrightarrow> ?card")
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (no_better_than x carrier relation \<subseteq> no_better_than y carrier relation) = (card (no_better_than x carrier relation) \<le> card (no_better_than y carrier relation))
[PROOF STEP]
proof
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. no_better_than x carrier relation \<subseteq> no_better_than y carrier relation \<Longrightarrow> card (no_better_than x carrier relation) \<le> card (no_better_than y carrier relation)
 2. card (no_better_than x carrier relation) \<le> card (no_better_than y carrier relation) \<Longrightarrow> no_better_than x carrier relation \<subseteq> no_better_than y carrier relation
[PROOF STEP]
assume "?nbt"
[PROOF STATE]
proof (state)
this:
no_better_than x carrier relation \<subseteq> no_better_than y carrier relation

goal (2 subgoals):
 1. no_better_than x carrier relation \<subseteq> no_better_than y carrier relation \<Longrightarrow> card (no_better_than x carrier relation) \<le> card (no_better_than y carrier relation)
 2. card (no_better_than x carrier relation) \<le> card (no_better_than y carrier relation) \<Longrightarrow> no_better_than x carrier relation \<subseteq> no_better_than y carrier relation
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
no_better_than x carrier relation \<subseteq> no_better_than y carrier relation
[PROOF STEP]
show "?card"
[PROOF STATE]
proof (prove)
using this:
no_better_than x carrier relation \<subseteq> no_better_than y carrier relation

goal (1 subgoal):
 1. card (no_better_than x carrier relation) \<le> card (no_better_than y carrier relation)
[PROOF STEP]
by (simp add: assms(2) card_mono fnt_carrier_fnt_nbt)
[PROOF STATE]
proof (state)
this:
card (no_better_than x carrier relation) \<le> card (no_better_than y carrier relation)

goal (1 subgoal):
 1. card (no_better_than x carrier relation) \<le> card (no_better_than y carrier relation) \<Longrightarrow> no_better_than x carrier relation \<subseteq> no_better_than y carrier relation
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. card (no_better_than x carrier relation) \<le> card (no_better_than y carrier relation) \<Longrightarrow> no_better_than x carrier relation \<subseteq> no_better_than y carrier relation
[PROOF STEP]
assume "?card"
[PROOF STATE]
proof (state)
this:
card (no_better_than x carrier relation) \<le> card (no_better_than y carrier relation)

goal (1 subgoal):
 1. card (no_better_than x carrier relation) \<le> card (no_better_than y carrier relation) \<Longrightarrow> no_better_than x carrier relation \<subseteq> no_better_than y carrier relation
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
card (no_better_than x carrier relation) \<le> card (no_better_than y carrier relation)
[PROOF STEP]
show "?nbt"
[PROOF STATE]
proof (prove)
using this:
card (no_better_than x carrier relation) \<le> card (no_better_than y carrier relation)

goal (1 subgoal):
 1. no_better_than x carrier relation \<subseteq> no_better_than y carrier relation
[PROOF STEP]
by (metis  assms(1) card_seteq fnt_carrier_fnt_nbt nbt_nest)
[PROOF STATE]
proof (state)
this:
no_better_than x carrier relation \<subseteq> no_better_than y carrier relation

goal:
No subgoals!
[PROOF STEP]
qed


[STATEMENT]
lemma imod_iless_divisor: "\<lbrakk> 0 < (n::enat); m \<noteq> \<infinity> \<rbrakk>  \<Longrightarrow> m mod n < n"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<lbrakk>0 < n; m \<noteq> \<infinity>\<rbrakk> \<Longrightarrow> m mod n < n
[PROOF STEP]
by (case_tac m, simp_all) (case_tac n, simp_all)


[STATEMENT]
lemma mcalc_iff: "\<sigma> \<turnstile> c \<longleftrightarrow> infTp \<sigma> \<or> (\<forall> x \<in> nvC c. tpOfV x \<noteq> \<sigma>)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (\<sigma> \<turnstile> c) = (infTp \<sigma> \<or> (\<forall>x\<in>nvC c. tpOfV x \<noteq> \<sigma>))
[PROOF STEP]
unfolding mcalc.simps
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. ((\<exists>\<sigma>' ca. \<sigma> = \<sigma>' \<and> c = ca \<and> infTp \<sigma>') \<or> (\<exists>ca \<sigma>'. \<sigma> = \<sigma>' \<and> c = ca \<and> (\<forall>x\<in>nvC ca. tpOfV x \<noteq> \<sigma>'))) = (infTp \<sigma> \<or> (\<forall>x\<in>nvC c. tpOfV x \<noteq> \<sigma>))
[PROOF STEP]
by simp


[STATEMENT]
lemma diagonal_step_dvd1[simp]:
  fixes A::"'a::{bezout_ring}^'b::mod_type^'c::mod_type" and j i
  defines "v==case bezout (A $ from_nat i $ from_nat i) (A $ from_nat j $ from_nat j) of (p,q,u,v,d) \<Rightarrow> v"
  and "d==case bezout (A $ from_nat i $ from_nat i) (A $ from_nat j $ from_nat j) of (p,q,u,v,d) \<Rightarrow> d"
 shows "diagonal_step A i j d v $ from_nat i $ from_nat i dvd A $ from_nat i $ from_nat i"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. diagonal_step A i j d v $ from_nat i $ from_nat i dvd A $ from_nat i $ from_nat i
[PROOF STEP]
using ib
[PROOF STATE]
proof (prove)
using this:
is_bezout_ext bezout

goal (1 subgoal):
 1. diagonal_step A i j d v $ from_nat i $ from_nat i dvd A $ from_nat i $ from_nat i
[PROOF STEP]
unfolding is_bezout_ext_def diagonal_step_def v_def d_def
[PROOF STATE]
proof (prove)
using this:
\<forall>a b. let (p, q, u, v, gcd_a_b) = bezout a b in p * a + q * b = gcd_a_b \<and> gcd_a_b dvd a \<and> gcd_a_b dvd b \<and> (\<forall>d'. d' dvd a \<and> d' dvd b \<longrightarrow> d' dvd gcd_a_b) \<and> gcd_a_b * u = - b \<and> gcd_a_b * v = a

goal (1 subgoal):
 1. (\<chi>a b. if a = from_nat i \<and> b = from_nat i then case bezout (A $ from_nat i $ from_nat i) (A $ from_nat j $ from_nat j) of (p, q, u, v, d) \<Rightarrow> d else if a = from_nat j \<and> b = from_nat j then (case bezout (A $ from_nat i $ from_nat i) (A $ from_nat j $ from_nat j) of (p, q, u, v, d) \<Rightarrow> v) * A $ from_nat j $ from_nat j else A $ a $ b) $ from_nat i $ from_nat i dvd A $ from_nat i $ from_nat i
[PROOF STEP]
by (auto simp add: split_beta)


[STATEMENT]
lemma sum_mset_delta':
  "sum_mset (image_mset (\<lambda>x. if y = x then c else 0) A) = c * of_nat (count A y)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (\<Sum>x\<in>#A. if y = x then c else (0::'a)) = c * of_nat (count A y)
[PROOF STEP]
by (induction A) (simp_all add: algebra_simps)


[STATEMENT]
lemma Gromov_converging_at_boundary_converges:
  assumes "Gromov_converging_at_boundary u"
  shows "\<exists>x \<in> Gromov_boundary. (\<lambda>n. to_Gromov_completion (u n)) \<longlonglongrightarrow> x"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<exists>x\<in>Gromov_boundary. (\<lambda>n. to_Gromov_completion (u n)) \<longlonglongrightarrow> x
[PROOF STEP]
apply (rule bexI[of _ "abs_Gromov_completion u"])
[PROOF STATE]
proof (prove)
goal (2 subgoals):
 1. (\<lambda>n. to_Gromov_completion (u n)) \<longlonglongrightarrow> abs_Gromov_completion u
 2. abs_Gromov_completion u \<in> Gromov_boundary
[PROOF STEP]
apply (subst Gromov_completion_converge_to_boundary)
[PROOF STATE]
proof (prove)
goal (3 subgoals):
 1. abs_Gromov_completion u \<in> Gromov_boundary
 2. Gromov_completion_rel u u \<and> abs_Gromov_completion u = abs_Gromov_completion u
 3. abs_Gromov_completion u \<in> Gromov_boundary
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
Gromov_converging_at_boundary u

goal (3 subgoals):
 1. abs_Gromov_completion u \<in> Gromov_boundary
 2. Gromov_completion_rel u u \<and> abs_Gromov_completion u = abs_Gromov_completion u
 3. abs_Gromov_completion u \<in> Gromov_boundary
[PROOF STEP]
by (auto simp add: Gromov_converging_at_boundary_rel)


[STATEMENT]
lemma sign_normal_of_Float:"sign (normal_of_Float x) = (if x > 0 then 0 else 1)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. sign (normal_of_Float x) = (if 0 < x then 0 else 1)
[PROOF STEP]
by transfer (auto simp: Let_def mantissa_pos_iff)


[STATEMENT]
lemma pow_generator_mod_int: "\<^bold>g [^] ((k::int) mod order G) = \<^bold>g [^] k"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<^bold>g [^] (k mod int (order G)) = \<^bold>g [^] k
[PROOF STEP]
proof(cases "order G > 0")
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. 0 < order G \<Longrightarrow> \<^bold>g [^] (k mod int (order G)) = \<^bold>g [^] k
 2. \<not> 0 < order G \<Longrightarrow> \<^bold>g [^] (k mod int (order G)) = \<^bold>g [^] k
[PROOF STEP]
case True
[PROOF STATE]
proof (state)
this:
0 < order G

goal (2 subgoals):
 1. 0 < order G \<Longrightarrow> \<^bold>g [^] (k mod int (order G)) = \<^bold>g [^] k
 2. \<not> 0 < order G \<Longrightarrow> \<^bold>g [^] (k mod int (order G)) = \<^bold>g [^] k
[PROOF STEP]
obtain n :: int where n: "k = n * order G + k mod order G"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (\<And>n. k = n * int (order G) + k mod int (order G) \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by (metis div_mult_mod_eq)
[PROOF STATE]
proof (state)
this:
k = n * int (order G) + k mod int (order G)

goal (2 subgoals):
 1. 0 < order G \<Longrightarrow> \<^bold>g [^] (k mod int (order G)) = \<^bold>g [^] k
 2. \<not> 0 < order G \<Longrightarrow> \<^bold>g [^] (k mod int (order G)) = \<^bold>g [^] k
[PROOF STEP]
have "\<^bold>g [^] k = (\<^bold>g [^] order G) [^] n \<otimes> \<^bold>g [^] (k mod order G)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<^bold>g [^] k = (\<^bold>g [^] order G) [^] n \<otimes> \<^bold>g [^] (k mod int (order G))
[PROOF STEP]
apply(subst n)
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<^bold>g [^] (n * int (order G) + k mod int (order G)) = (\<^bold>g [^] order G) [^] n \<otimes> \<^bold>g [^] (k mod int (order G))
[PROOF STEP]
apply(simp add: int_pow_mult int_pow_pow mult_ac)
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<^bold>g [^] (n * int (order G)) = (\<^bold>g [^] order G) [^] n
[PROOF STEP]
by (metis generator_closed int_pow_int int_pow_pow mult.commute)
[PROOF STATE]
proof (state)
this:
\<^bold>g [^] k = (\<^bold>g [^] order G) [^] n \<otimes> \<^bold>g [^] (k mod int (order G))

goal (2 subgoals):
 1. 0 < order G \<Longrightarrow> \<^bold>g [^] (k mod int (order G)) = \<^bold>g [^] k
 2. \<not> 0 < order G \<Longrightarrow> \<^bold>g [^] (k mod int (order G)) = \<^bold>g [^] k
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
\<^bold>g [^] k = (\<^bold>g [^] order G) [^] n \<otimes> \<^bold>g [^] (k mod int (order G))
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
\<^bold>g [^] k = (\<^bold>g [^] order G) [^] n \<otimes> \<^bold>g [^] (k mod int (order G))

goal (1 subgoal):
 1. \<^bold>g [^] (k mod int (order G)) = \<^bold>g [^] k
[PROOF STEP]
by(simp add: generator_pow_order)
[PROOF STATE]
proof (state)
this:
\<^bold>g [^] (k mod int (order G)) = \<^bold>g [^] k

goal (1 subgoal):
 1. \<not> 0 < order G \<Longrightarrow> \<^bold>g [^] (k mod int (order G)) = \<^bold>g [^] k
[PROOF STEP]
qed simp


[STATEMENT]
lemma jump_const[simp]:"jump (\<lambda>_. c) a = 0"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. jump (\<lambda>_. c) a = 0
[PROOF STEP]
proof -
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. jump (\<lambda>_. c) a = 0
[PROOF STEP]
have False when "LIM x (at_left a). c :> at_bot"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. False
[PROOF STEP]
apply (rule not_tendsto_and_filterlim_at_infinity[of "at_left a" "\<lambda>_. c" c])
[PROOF STATE]
proof (prove)
goal (3 subgoals):
 1. at_left a \<noteq> bot
 2. ((\<lambda>_. c) \<longlongrightarrow> c) (at_left a)
 3. LIM _ at_left a. c :> at_infinity
[PROOF STEP]
apply auto
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. LIM _ at_left a. c :> at_infinity
[PROOF STEP]
using at_bot_le_at_infinity filterlim_mono that
[PROOF STATE]
proof (prove)
using this:
at_bot \<le> at_infinity
\<lbrakk>filterlim ?f ?F2.0 ?F1.0; ?F2.0 \<le> ?F2'; ?F1' \<le> ?F1.0\<rbrakk> \<Longrightarrow> filterlim ?f ?F2' ?F1'
LIM x at_left a. c :> at_bot

goal (1 subgoal):
 1. LIM _ at_left a. c :> at_infinity
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
LIM x at_left a. c :> at_bot \<Longrightarrow> False

goal (1 subgoal):
 1. jump (\<lambda>_. c) a = 0
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
LIM x at_left a. c :> at_bot \<Longrightarrow> False

goal (1 subgoal):
 1. jump (\<lambda>_. c) a = 0
[PROOF STEP]
have False when "LIM x (at_left a). c :> at_top"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. False
[PROOF STEP]
apply (rule not_tendsto_and_filterlim_at_infinity[of "at_left a" "\<lambda>_. c" c])
[PROOF STATE]
proof (prove)
goal (3 subgoals):
 1. at_left a \<noteq> bot
 2. ((\<lambda>_. c) \<longlongrightarrow> c) (at_left a)
 3. LIM _ at_left a. c :> at_infinity
[PROOF STEP]
apply auto
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. LIM _ at_left a. c :> at_infinity
[PROOF STEP]
using at_top_le_at_infinity filterlim_mono that
[PROOF STATE]
proof (prove)
using this:
at_top \<le> at_infinity
\<lbrakk>filterlim ?f ?F2.0 ?F1.0; ?F2.0 \<le> ?F2'; ?F1' \<le> ?F1.0\<rbrakk> \<Longrightarrow> filterlim ?f ?F2' ?F1'
LIM x at_left a. c :> at_top

goal (1 subgoal):
 1. LIM _ at_left a. c :> at_infinity
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
LIM x at_left a. c :> at_top \<Longrightarrow> False

goal (1 subgoal):
 1. jump (\<lambda>_. c) a = 0
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
LIM x at_left a. c :> at_bot \<Longrightarrow> False
LIM x at_left a. c :> at_top \<Longrightarrow> False
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
LIM x at_left a. c :> at_bot \<Longrightarrow> False
LIM x at_left a. c :> at_top \<Longrightarrow> False

goal (1 subgoal):
 1. jump (\<lambda>_. c) a = 0
[PROOF STEP]
unfolding jump_def
[PROOF STATE]
proof (prove)
using this:
LIM x at_left a. c :> at_bot \<Longrightarrow> False
LIM x at_left a. c :> at_top \<Longrightarrow> False

goal (1 subgoal):
 1. (if (LIM _ at_left a. c :> at_bot) \<and> (LIM _ at_right a. c :> at_top) then 1 else if (LIM _ at_left a. c :> at_top) \<and> (LIM _ at_right a. c :> at_bot) then - 1 else 0) = 0
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
jump (\<lambda>_. c) a = 0

goal:
No subgoals!
[PROOF STEP]
qed


[STATEMENT]
lemma of_rat_less_eq: "(of_rat r :: 'a::linordered_field) \<le> of_rat s \<longleftrightarrow> r \<le> s"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (of_rat r \<le> of_rat s) = (r \<le> s)
[PROOF STEP]
unfolding le_less
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (of_rat r < of_rat s \<or> of_rat r = of_rat s) = (r < s \<or> r = s)
[PROOF STEP]
by (auto simp add: of_rat_less)


[STATEMENT]
theorem goedel_first_strong_ex:
"\<omega>consistent \<Longrightarrow> \<exists> \<phi>. \<phi> \<in> fmla \<and> \<not> prv \<phi> \<and> \<not> prv (neg \<phi>) \<and> isTrue \<phi>"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<omega>consistent \<Longrightarrow> \<exists>\<phi>. \<phi> \<in> fmla \<and> \<not> prv \<phi> \<and> \<not> prv (neg \<phi>) \<and> isTrue \<phi>
[PROOF STEP]
using goedel_first_strong
[PROOF STATE]
proof (prove)
using this:
\<omega>consistent \<Longrightarrow> \<not> prv \<phi>G \<and> \<not> prv (neg \<phi>G) \<and> isTrue \<phi>G

goal (1 subgoal):
 1. \<omega>consistent \<Longrightarrow> \<exists>\<phi>. \<phi> \<in> fmla \<and> \<not> prv \<phi> \<and> \<not> prv (neg \<phi>) \<and> isTrue \<phi>
[PROOF STEP]
by (intro exI[of _ \<phi>G]) blast


[STATEMENT]
lemma concat_nth:
  assumes "m < length xs" and "n < length (xs ! m)"
    and "i = sum_list (map length (take m xs)) + n"
  shows "concat xs ! i = xs ! m ! n"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. concat xs ! i = xs ! m ! n
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
m < length xs
n < length (xs ! m)
i = sum_list (map length (take m xs)) + n

goal (1 subgoal):
 1. concat xs ! i = xs ! m ! n
[PROOF STEP]
proof (induct xs arbitrary: m n i)
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<And>m n i. \<lbrakk>m < length []; n < length ([] ! m); i = sum_list (map length (take m [])) + n\<rbrakk> \<Longrightarrow> concat [] ! i = [] ! m ! n
 2. \<And>a xs m n i. \<lbrakk>\<And>m n i. \<lbrakk>m < length xs; n < length (xs ! m); i = sum_list (map length (take m xs)) + n\<rbrakk> \<Longrightarrow> concat xs ! i = xs ! m ! n; m < length (a # xs); n < length ((a # xs) ! m); i = sum_list (map length (take m (a # xs))) + n\<rbrakk> \<Longrightarrow> concat (a # xs) ! i = (a # xs) ! m ! n
[PROOF STEP]
case (Cons x xs)
[PROOF STATE]
proof (state)
this:
\<lbrakk>?m < length xs; ?n < length (xs ! ?m); ?i = sum_list (map length (take ?m xs)) + ?n\<rbrakk> \<Longrightarrow> concat xs ! ?i = xs ! ?m ! ?n
m < length (x # xs)
n < length ((x # xs) ! m)
i = sum_list (map length (take m (x # xs))) + n

goal (2 subgoals):
 1. \<And>m n i. \<lbrakk>m < length []; n < length ([] ! m); i = sum_list (map length (take m [])) + n\<rbrakk> \<Longrightarrow> concat [] ! i = [] ! m ! n
 2. \<And>a xs m n i. \<lbrakk>\<And>m n i. \<lbrakk>m < length xs; n < length (xs ! m); i = sum_list (map length (take m xs)) + n\<rbrakk> \<Longrightarrow> concat xs ! i = xs ! m ! n; m < length (a # xs); n < length ((a # xs) ! m); i = sum_list (map length (take m (a # xs))) + n\<rbrakk> \<Longrightarrow> concat (a # xs) ! i = (a # xs) ! m ! n
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. concat (x # xs) ! i = (x # xs) ! m ! n
[PROOF STEP]
proof (cases m)
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. m = 0 \<Longrightarrow> concat (x # xs) ! i = (x # xs) ! m ! n
 2. \<And>nat. m = Suc nat \<Longrightarrow> concat (x # xs) ! i = (x # xs) ! m ! n
[PROOF STEP]
case 0
[PROOF STATE]
proof (state)
this:
m = 0

goal (2 subgoals):
 1. m = 0 \<Longrightarrow> concat (x # xs) ! i = (x # xs) ! m ! n
 2. \<And>nat. m = Suc nat \<Longrightarrow> concat (x # xs) ! i = (x # xs) ! m ! n
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
m = 0
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
m = 0

goal (1 subgoal):
 1. concat (x # xs) ! i = (x # xs) ! m ! n
[PROOF STEP]
using Cons
[PROOF STATE]
proof (prove)
using this:
m = 0
\<lbrakk>?m < length xs; ?n < length (xs ! ?m); ?i = sum_list (map length (take ?m xs)) + ?n\<rbrakk> \<Longrightarrow> concat xs ! ?i = xs ! ?m ! ?n
m < length (x # xs)
n < length ((x # xs) ! m)
i = sum_list (map length (take m (x # xs))) + n

goal (1 subgoal):
 1. concat (x # xs) ! i = (x # xs) ! m ! n
[PROOF STEP]
by (simp add: nth_append)
[PROOF STATE]
proof (state)
this:
concat (x # xs) ! i = (x # xs) ! m ! n

goal (1 subgoal):
 1. \<And>nat. m = Suc nat \<Longrightarrow> concat (x # xs) ! i = (x # xs) ! m ! n
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>nat. m = Suc nat \<Longrightarrow> concat (x # xs) ! i = (x # xs) ! m ! n
[PROOF STEP]
case (Suc k)
[PROOF STATE]
proof (state)
this:
m = Suc k

goal (1 subgoal):
 1. \<And>nat. m = Suc nat \<Longrightarrow> concat (x # xs) ! i = (x # xs) ! m ! n
[PROOF STEP]
with Cons(1) [of k n "i - length x"] and Cons(2-)
[PROOF STATE]
proof (chain)
picking this:
\<lbrakk>k < length xs; n < length (xs ! k); i - length x = sum_list (map length (take k xs)) + n\<rbrakk> \<Longrightarrow> concat xs ! (i - length x) = xs ! k ! n
m < length (x # xs)
n < length ((x # xs) ! m)
i = sum_list (map length (take m (x # xs))) + n
m = Suc k
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>k < length xs; n < length (xs ! k); i - length x = sum_list (map length (take k xs)) + n\<rbrakk> \<Longrightarrow> concat xs ! (i - length x) = xs ! k ! n
m < length (x # xs)
n < length ((x # xs) ! m)
i = sum_list (map length (take m (x # xs))) + n
m = Suc k

goal (1 subgoal):
 1. concat (x # xs) ! i = (x # xs) ! m ! n
[PROOF STEP]
by (simp_all add: nth_append)
[PROOF STATE]
proof (state)
this:
concat (x # xs) ! i = (x # xs) ! m ! n

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
concat (x # xs) ! i = (x # xs) ! m ! n

goal (1 subgoal):
 1. \<And>m n i. \<lbrakk>m < length []; n < length ([] ! m); i = sum_list (map length (take m [])) + n\<rbrakk> \<Longrightarrow> concat [] ! i = [] ! m ! n
[PROOF STEP]
qed simp


[STATEMENT]
lemma less_dual_def_var: "(\<partial> y < \<partial> x) = (x < y)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (\<partial> y < \<partial> x) = (x < y)
[PROOF STEP]
by (simp add: dual_dual_ord less_le_not_le)


[STATEMENT]
lemma reduce_system_matrix_signs_helper:
  fixes p:: "real poly"
  fixes qs :: "real poly list"
  fixes subsets :: "nat list list"
  fixes signs :: "rat list list"
  fixes S:: "nat list"
  assumes well_def_h: "\<forall>x. List.member S x \<longrightarrow> x < length signs"
  assumes nonzero: "p \<noteq> 0"
  shows "matrix_A (take_indices signs S) subsets = take_cols_from_matrix (matrix_A signs subsets) S"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. M_mat (take_indices signs S) subsets = take_cols_from_matrix (M_mat signs subsets) S
[PROOF STEP]
using reduce_system_matrix_signs_helper_aux alt_matrix_char assms
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>\<forall>x. List.member ?S x \<longrightarrow> x < length ?signs; ?p \<noteq> 0\<rbrakk> \<Longrightarrow> alt_matrix_A (take_indices ?signs ?S) ?subsets = take_cols_from_matrix (alt_matrix_A ?signs ?subsets) ?S
alt_matrix_A ?signs ?subsets = M_mat ?signs ?subsets
\<forall>x. List.member S x \<longrightarrow> x < length signs
p \<noteq> 0

goal (1 subgoal):
 1. M_mat (take_indices signs S) subsets = take_cols_from_matrix (M_mat signs subsets) S
[PROOF STEP]
by auto


[STATEMENT]
lemma (in encoding_wrt_barbs) indRelRSTPO_impl_SRel_and_TRel_reflect_barbs:
  fixes SRel :: "('procS \<times> 'procS) set"
    and TRel :: "('procT \<times> 'procT) set"
  assumes reflection: "rel_reflects_barbs (indRelRSTPO SRel TRel) (STCalWB SWB TWB)"
  shows "rel_reflects_barbs SRel SWB"
    and "rel_reflects_barbs TRel TWB"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. rel_reflects_binary_pred SRel (\<lambda>b. hasBarb b SWB) &&& rel_reflects_binary_pred TRel (\<lambda>b. hasBarb b TWB)
[PROOF STEP]
proof -
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. rel_reflects_binary_pred SRel (\<lambda>b. hasBarb b SWB)
 2. rel_reflects_binary_pred TRel (\<lambda>b. hasBarb b TWB)
[PROOF STEP]
show "rel_reflects_barbs SRel SWB"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. rel_reflects_binary_pred SRel (\<lambda>b. hasBarb b SWB)
[PROOF STEP]
using reflection rel_with_source_impl_SRel_reflects_barbs[where
                        Rel="indRelRSTPO SRel TRel" and SRel="SRel"]
[PROOF STATE]
proof (prove)
using this:
rel_reflects_binary_pred (indRelRSTPO SRel TRel) (\<lambda>b. hasBarb b (STCalWB SWB TWB))
rel_reflects_binary_pred (indRelRSTPO SRel TRel) (\<lambda>b. hasBarb b (STCalWB SWB TWB)) \<and> (\<forall>S1 S2. (S1, S2) \<in> SRel \<longrightarrow> SourceTerm S1 \<lesssim>\<lbrakk>\<cdot>\<rbrakk>R<SRel,TRel> SourceTerm S2) \<Longrightarrow> rel_reflects_binary_pred SRel (\<lambda>b. hasBarb b SWB)

goal (1 subgoal):
 1. rel_reflects_binary_pred SRel (\<lambda>b. hasBarb b SWB)
[PROOF STEP]
by (simp add: indRelRSTPO.source)
[PROOF STATE]
proof (state)
this:
rel_reflects_binary_pred SRel (\<lambda>b. hasBarb b SWB)

goal (1 subgoal):
 1. rel_reflects_binary_pred TRel (\<lambda>b. hasBarb b TWB)
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. rel_reflects_binary_pred TRel (\<lambda>b. hasBarb b TWB)
[PROOF STEP]
show "rel_reflects_barbs TRel TWB"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. rel_reflects_binary_pred TRel (\<lambda>b. hasBarb b TWB)
[PROOF STEP]
using reflection rel_with_target_impl_TRel_reflects_barbs[where
                        Rel="indRelRSTPO SRel TRel" and TRel="TRel"]
[PROOF STATE]
proof (prove)
using this:
rel_reflects_binary_pred (indRelRSTPO SRel TRel) (\<lambda>b. hasBarb b (STCalWB SWB TWB))
rel_reflects_binary_pred (indRelRSTPO SRel TRel) (\<lambda>b. hasBarb b (STCalWB SWB TWB)) \<and> (\<forall>T1 T2. (T1, T2) \<in> TRel \<longrightarrow> TargetTerm T1 \<lesssim>\<lbrakk>\<cdot>\<rbrakk>R<SRel,TRel> TargetTerm T2) \<Longrightarrow> rel_reflects_binary_pred TRel (\<lambda>b. hasBarb b TWB)

goal (1 subgoal):
 1. rel_reflects_binary_pred TRel (\<lambda>b. hasBarb b TWB)
[PROOF STEP]
by (simp add: indRelRSTPO.target)
[PROOF STATE]
proof (state)
this:
rel_reflects_binary_pred TRel (\<lambda>b. hasBarb b TWB)

goal:
No subgoals!
[PROOF STEP]
qed


[STATEMENT]
lemma bigo_mult8:
"\<forall>x. f x \<noteq> 0 \<Longrightarrow> O(f * g) = O(f::'a \<Rightarrow> ('b::linordered_field)) * O(g)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<forall>x. f x \<noteq> (0::'b) \<Longrightarrow> O(f * g) = O(f) * O(g)
[PROOF STEP]
by (metis bigo_mult bigo_mult7 order_antisym_conv)


[STATEMENT]
lemma map_ugraph_trans: "map_ugraph (g \<circ> f) = (map_ugraph g) \<circ> (map_ugraph f)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. map_ugraph (g \<circ> f) = map_ugraph g \<circ> map_ugraph f
[PROOF STEP]
by (simp add: fun_eq_iff image_image)


[STATEMENT]
lemma add2_image_real_of_ereal_image_greaterThanLessThan:
  "(\<lambda>x. x + c) ` real_of_ereal ` {l <..< u} = real_of_ereal ` {l + c <..< u + c}"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (\<lambda>x. x + c) ` real_of_ereal ` {l<..<u} = real_of_ereal ` {l + ereal c<..<u + ereal c}
[PROOF STEP]
using add_image_real_of_ereal_image_greaterThanLessThan[of c l u]
[PROOF STATE]
proof (prove)
using this:
(+) c ` real_of_ereal ` {l<..<u} = real_of_ereal ` {ereal c + l<..<ereal c + u}

goal (1 subgoal):
 1. (\<lambda>x. x + c) ` real_of_ereal ` {l<..<u} = real_of_ereal ` {l + ereal c<..<u + ereal c}
[PROOF STEP]
by (metis add.commute image_cong)


[STATEMENT]
lemma PosOrd_assym:
  assumes "v1 :\<sqsubset>val v2"
  shows "\<not>(v2 :\<sqsubset>val v1)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<not> v2 :\<sqsubset>val v1
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
v1 :\<sqsubset>val v2

goal (1 subgoal):
 1. \<not> v2 :\<sqsubset>val v1
[PROOF STEP]
using PosOrd_irrefl PosOrd_trans
[PROOF STATE]
proof (prove)
using this:
v1 :\<sqsubset>val v2
?v :\<sqsubset>val ?v \<Longrightarrow> False
\<lbrakk>?v1.0 :\<sqsubset>val ?v2.0; ?v2.0 :\<sqsubset>val ?v3.0\<rbrakk> \<Longrightarrow> ?v1.0 :\<sqsubset>val ?v3.0

goal (1 subgoal):
 1. \<not> v2 :\<sqsubset>val v1
[PROOF STEP]
by blast


[STATEMENT]
lemma mod_ring_minus64: "(mod_ring_rel64 ===> mod_ring_rel64 ===> mod_ring_rel64) (minus_p64 pp) (-)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (mod_ring_rel64 ===> mod_ring_rel64 ===> mod_ring_rel64) (minus_p64 pp) (-)
[PROOF STEP]
using urel64_minus mod_ring_minus
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>urel64 ?x ?y; urel64 ?x' ?y'\<rbrakk> \<Longrightarrow> urel64 (minus_p64 pp ?x ?x') (minus_p p ?y ?y')
(mod_ring_rel ===> mod_ring_rel ===> mod_ring_rel) (minus_p p) (-)

goal (1 subgoal):
 1. (mod_ring_rel64 ===> mod_ring_rel64 ===> mod_ring_rel64) (minus_p64 pp) (-)
[PROOF STEP]
unfolding mod_ring_rel64_def rel_fun_def
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>urel64 ?x ?y; urel64 ?x' ?y'\<rbrakk> \<Longrightarrow> urel64 (minus_p64 pp ?x ?x') (minus_p p ?y ?y')
\<forall>x y. mod_ring_rel x y \<longrightarrow> (\<forall>xa ya. mod_ring_rel xa ya \<longrightarrow> mod_ring_rel (minus_p p x xa) (y - ya))

goal (1 subgoal):
 1. \<forall>x y. (\<exists>z. urel64 x z \<and> mod_ring_rel z y) \<longrightarrow> (\<forall>xa ya. (\<exists>z. urel64 xa z \<and> mod_ring_rel z ya) \<longrightarrow> (\<exists>z. urel64 (minus_p64 pp x xa) z \<and> mod_ring_rel z (y - ya)))
[PROOF STEP]
by blast


[STATEMENT]
lemma geod_upper:
  assumes "a \<le> b" "b \<le> 2^n"
  shows "dist (geod n a) (geod n b) \<le> (b-a) * dist x0 y0 / 2^n"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. dist (geod n a) (geod n b) \<le> (real b - real a) * dist x0 y0 / 2 ^ n
[PROOF STEP]
proof -
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. dist (geod n a) (geod n b) \<le> (real b - real a) * dist x0 y0 / 2 ^ n
[PROOF STEP]
have *: "a+k > 2^n \<or> dist (geod n a) (geod n (a+k)) \<le> k * dist x0 y0 / 2^n" for k
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. 2 ^ n < a + k \<or> dist (geod n a) (geod n (a + k)) \<le> real k * dist x0 y0 / 2 ^ n
[PROOF STEP]
proof (induction k)
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. 2 ^ n < a + 0 \<or> dist (geod n a) (geod n (a + 0)) \<le> real 0 * dist x0 y0 / 2 ^ n
 2. \<And>k. 2 ^ n < a + k \<or> dist (geod n a) (geod n (a + k)) \<le> real k * dist x0 y0 / 2 ^ n \<Longrightarrow> 2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n
[PROOF STEP]
case 0
[PROOF STATE]
proof (state)
this:

goal (2 subgoals):
 1. 2 ^ n < a + 0 \<or> dist (geod n a) (geod n (a + 0)) \<le> real 0 * dist x0 y0 / 2 ^ n
 2. \<And>k. 2 ^ n < a + k \<or> dist (geod n a) (geod n (a + k)) \<le> real k * dist x0 y0 / 2 ^ n \<Longrightarrow> 2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. 2 ^ n < a + 0 \<or> dist (geod n a) (geod n (a + 0)) \<le> real 0 * dist x0 y0 / 2 ^ n
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
2 ^ n < a + 0 \<or> dist (geod n a) (geod n (a + 0)) \<le> real 0 * dist x0 y0 / 2 ^ n

goal (1 subgoal):
 1. \<And>k. 2 ^ n < a + k \<or> dist (geod n a) (geod n (a + k)) \<le> real k * dist x0 y0 / 2 ^ n \<Longrightarrow> 2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>k. 2 ^ n < a + k \<or> dist (geod n a) (geod n (a + k)) \<le> real k * dist x0 y0 / 2 ^ n \<Longrightarrow> 2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n
[PROOF STEP]
case (Suc k)
[PROOF STATE]
proof (state)
this:
2 ^ n < a + k \<or> dist (geod n a) (geod n (a + k)) \<le> real k * dist x0 y0 / 2 ^ n

goal (1 subgoal):
 1. \<And>k. 2 ^ n < a + k \<or> dist (geod n a) (geod n (a + k)) \<le> real k * dist x0 y0 / 2 ^ n \<Longrightarrow> 2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. 2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n
[PROOF STEP]
proof (cases "2 ^ n < a + Suc k")
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. 2 ^ n < a + Suc k \<Longrightarrow> 2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n
 2. \<not> 2 ^ n < a + Suc k \<Longrightarrow> 2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n
[PROOF STEP]
case True
[PROOF STATE]
proof (state)
this:
2 ^ n < a + Suc k

goal (2 subgoals):
 1. 2 ^ n < a + Suc k \<Longrightarrow> 2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n
 2. \<not> 2 ^ n < a + Suc k \<Longrightarrow> 2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
2 ^ n < a + Suc k
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
2 ^ n < a + Suc k

goal (1 subgoal):
 1. 2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n

goal (1 subgoal):
 1. \<not> 2 ^ n < a + Suc k \<Longrightarrow> 2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<not> 2 ^ n < a + Suc k \<Longrightarrow> 2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n
[PROOF STEP]
case False
[PROOF STATE]
proof (state)
this:
\<not> 2 ^ n < a + Suc k

goal (1 subgoal):
 1. \<not> 2 ^ n < a + Suc k \<Longrightarrow> 2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
\<not> 2 ^ n < a + Suc k
[PROOF STEP]
have *: "a + k < 2 ^ n"
[PROOF STATE]
proof (prove)
using this:
\<not> 2 ^ n < a + Suc k

goal (1 subgoal):
 1. a + k < 2 ^ n
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
a + k < 2 ^ n

goal (1 subgoal):
 1. \<not> 2 ^ n < a + Suc k \<Longrightarrow> 2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n
[PROOF STEP]
have "dist (geod n a) (geod n (a + Suc k)) \<le> dist (geod n a) (geod n (a+k)) + dist (geod n (a+k)) (geod n (a+Suc k))"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. dist (geod n a) (geod n (a + Suc k)) \<le> dist (geod n a) (geod n (a + k)) + dist (geod n (a + k)) (geod n (a + Suc k))
[PROOF STEP]
using dist_triangle
[PROOF STATE]
proof (prove)
using this:
dist ?x ?z \<le> dist ?x ?y + dist ?y ?z

goal (1 subgoal):
 1. dist (geod n a) (geod n (a + Suc k)) \<le> dist (geod n a) (geod n (a + k)) + dist (geod n (a + k)) (geod n (a + Suc k))
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
dist (geod n a) (geod n (a + Suc k)) \<le> dist (geod n a) (geod n (a + k)) + dist (geod n (a + k)) (geod n (a + Suc k))

goal (1 subgoal):
 1. \<not> 2 ^ n < a + Suc k \<Longrightarrow> 2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n
[PROOF STEP]
also
[PROOF STATE]
proof (state)
this:
dist (geod n a) (geod n (a + Suc k)) \<le> dist (geod n a) (geod n (a + k)) + dist (geod n (a + k)) (geod n (a + Suc k))

goal (1 subgoal):
 1. \<not> 2 ^ n < a + Suc k \<Longrightarrow> 2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n
[PROOF STEP]
have "... \<le> k * dist x0 y0 / 2^n + dist x0 y0 / 2^n"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. dist (geod n a) (geod n (a + k)) + dist (geod n (a + k)) (geod n (a + Suc k)) \<le> real k * dist x0 y0 / 2 ^ n + dist x0 y0 / 2 ^ n
[PROOF STEP]
using Suc.IH * geod_distance_successor
[PROOF STATE]
proof (prove)
using this:
2 ^ n < a + k \<or> dist (geod n a) (geod n (a + k)) \<le> real k * dist x0 y0 / 2 ^ n
a + k < 2 ^ n
\<forall>a<2 ^ ?n. dist (geod ?n a) (geod ?n (Suc a)) = dist x0 y0 / 2 ^ ?n

goal (1 subgoal):
 1. dist (geod n a) (geod n (a + k)) + dist (geod n (a + k)) (geod n (a + Suc k)) \<le> real k * dist x0 y0 / 2 ^ n + dist x0 y0 / 2 ^ n
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
dist (geod n a) (geod n (a + k)) + dist (geod n (a + k)) (geod n (a + Suc k)) \<le> real k * dist x0 y0 / 2 ^ n + dist x0 y0 / 2 ^ n

goal (1 subgoal):
 1. \<not> 2 ^ n < a + Suc k \<Longrightarrow> 2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n
[PROOF STEP]
finally
[PROOF STATE]
proof (chain)
picking this:
dist (geod n a) (geod n (a + Suc k)) \<le> real k * dist x0 y0 / 2 ^ n + dist x0 y0 / 2 ^ n
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
dist (geod n a) (geod n (a + Suc k)) \<le> real k * dist x0 y0 / 2 ^ n + dist x0 y0 / 2 ^ n

goal (1 subgoal):
 1. 2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n
[PROOF STEP]
by (simp add: add_divide_distrib distrib_left mult.commute)
[PROOF STATE]
proof (state)
this:
2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
2 ^ n < a + Suc k \<or> dist (geod n a) (geod n (a + Suc k)) \<le> real (Suc k) * dist x0 y0 / 2 ^ n

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
2 ^ n < a + ?k \<or> dist (geod n a) (geod n (a + ?k)) \<le> real ?k * dist x0 y0 / 2 ^ n

goal (1 subgoal):
 1. dist (geod n a) (geod n b) \<le> (real b - real a) * dist x0 y0 / 2 ^ n
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. dist (geod n a) (geod n b) \<le> (real b - real a) * dist x0 y0 / 2 ^ n
[PROOF STEP]
using *[of "b-a"] assms
[PROOF STATE]
proof (prove)
using this:
2 ^ n < a + (b - a) \<or> dist (geod n a) (geod n (a + (b - a))) \<le> real (b - a) * dist x0 y0 / 2 ^ n
a \<le> b
b \<le> 2 ^ n

goal (1 subgoal):
 1. dist (geod n a) (geod n b) \<le> (real b - real a) * dist x0 y0 / 2 ^ n
[PROOF STEP]
by (simp add: of_nat_diff)
[PROOF STATE]
proof (state)
this:
dist (geod n a) (geod n b) \<le> (real b - real a) * dist x0 y0 / 2 ^ n

goal:
No subgoals!
[PROOF STEP]
qed


[STATEMENT]
lemma nnvs_card_ge_n: "\<lbrakk> n_nearest_verts w u n U; unvisited_verts u U \<noteq> {} \<rbrakk>
  \<Longrightarrow> card U \<ge> Suc n"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<lbrakk>n_nearest_verts w u n U; unvisited_verts u U \<noteq> {}\<rbrakk> \<Longrightarrow> Suc n \<le> card U
[PROOF STEP]
proof(induction rule: n_nearest_verts.induct)
[PROOF STATE]
proof (state)
goal (3 subgoals):
 1. \<And>u _. \<lbrakk>u \<in> verts G; unvisited_verts u {u} \<noteq> {}\<rbrakk> \<Longrightarrow> Suc 0 \<le> card {u}
 2. \<And>w u n U. \<lbrakk>n_nearest_verts w u n U; unvisited_verts u U \<noteq> {} \<Longrightarrow> Suc n \<le> card U; unvisited_verts u U \<noteq> {}; unvisited_verts u (insert (nearest_vert w u U) U) \<noteq> {}\<rbrakk> \<Longrightarrow> Suc (Suc n) \<le> card (insert (nearest_vert w u U) U)
 3. \<And>w u n U. \<lbrakk>n_nearest_verts w u n U; unvisited_verts u U \<noteq> {} \<Longrightarrow> Suc n \<le> card U; unvisited_verts u U = {}; unvisited_verts u U \<noteq> {}\<rbrakk> \<Longrightarrow> Suc (Suc n) \<le> card U
[PROOF STEP]
case (n_nnvs_unvis w u n U)
[PROOF STATE]
proof (state)
this:
n_nearest_verts w u n U
unvisited_verts u U \<noteq> {}
unvisited_verts u U \<noteq> {} \<Longrightarrow> Suc n \<le> card U
unvisited_verts u (insert (nearest_vert w u U) U) \<noteq> {}

goal (3 subgoals):
 1. \<And>u _. \<lbrakk>u \<in> verts G; unvisited_verts u {u} \<noteq> {}\<rbrakk> \<Longrightarrow> Suc 0 \<le> card {u}
 2. \<And>w u n U. \<lbrakk>n_nearest_verts w u n U; unvisited_verts u U \<noteq> {} \<Longrightarrow> Suc n \<le> card U; unvisited_verts u U \<noteq> {}; unvisited_verts u (insert (nearest_vert w u U) U) \<noteq> {}\<rbrakk> \<Longrightarrow> Suc (Suc n) \<le> card (insert (nearest_vert w u U) U)
 3. \<And>w u n U. \<lbrakk>n_nearest_verts w u n U; unvisited_verts u U \<noteq> {} \<Longrightarrow> Suc n \<le> card U; unvisited_verts u U = {}; unvisited_verts u U \<noteq> {}\<rbrakk> \<Longrightarrow> Suc (Suc n) \<le> card U
[PROOF STEP]
have "nearest_vert w u U \<notin> U"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. nearest_vert w u U \<notin> U
[PROOF STEP]
using nearest_vert_unvis[OF n_nnvs_unvis.hyps(2)] disj_unvis_vis
[PROOF STATE]
proof (prove)
using this:
nearest_vert ?w u U \<in> unvisited_verts u U
unvisited_verts ?u ?U \<inter> ?U = {}

goal (1 subgoal):
 1. nearest_vert w u U \<notin> U
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
nearest_vert w u U \<notin> U

goal (3 subgoals):
 1. \<And>u _. \<lbrakk>u \<in> verts G; unvisited_verts u {u} \<noteq> {}\<rbrakk> \<Longrightarrow> Suc 0 \<le> card {u}
 2. \<And>w u n U. \<lbrakk>n_nearest_verts w u n U; unvisited_verts u U \<noteq> {} \<Longrightarrow> Suc n \<le> card U; unvisited_verts u U \<noteq> {}; unvisited_verts u (insert (nearest_vert w u U) U) \<noteq> {}\<rbrakk> \<Longrightarrow> Suc (Suc n) \<le> card (insert (nearest_vert w u U) U)
 3. \<And>w u n U. \<lbrakk>n_nearest_verts w u n U; unvisited_verts u U \<noteq> {} \<Longrightarrow> Suc n \<le> card U; unvisited_verts u U = {}; unvisited_verts u U \<noteq> {}\<rbrakk> \<Longrightarrow> Suc (Suc n) \<le> card U
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
nearest_vert w u U \<notin> U
[PROOF STEP]
have "card (insert (nearest_vert w u U) U) = Suc (card U)"
[PROOF STATE]
proof (prove)
using this:
nearest_vert w u U \<notin> U

goal (1 subgoal):
 1. card (insert (nearest_vert w u U) U) = Suc (card U)
[PROOF STEP]
using n_nnvs_unvis.hyps(1) nnvs_finite
[PROOF STATE]
proof (prove)
using this:
nearest_vert w u U \<notin> U
n_nearest_verts w u n U
n_nearest_verts ?w ?u ?n ?U \<Longrightarrow> finite ?U

goal (1 subgoal):
 1. card (insert (nearest_vert w u U) U) = Suc (card U)
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
card (insert (nearest_vert w u U) U) = Suc (card U)

goal (3 subgoals):
 1. \<And>u _. \<lbrakk>u \<in> verts G; unvisited_verts u {u} \<noteq> {}\<rbrakk> \<Longrightarrow> Suc 0 \<le> card {u}
 2. \<And>w u n U. \<lbrakk>n_nearest_verts w u n U; unvisited_verts u U \<noteq> {} \<Longrightarrow> Suc n \<le> card U; unvisited_verts u U \<noteq> {}; unvisited_verts u (insert (nearest_vert w u U) U) \<noteq> {}\<rbrakk> \<Longrightarrow> Suc (Suc n) \<le> card (insert (nearest_vert w u U) U)
 3. \<And>w u n U. \<lbrakk>n_nearest_verts w u n U; unvisited_verts u U \<noteq> {} \<Longrightarrow> Suc n \<le> card U; unvisited_verts u U = {}; unvisited_verts u U \<noteq> {}\<rbrakk> \<Longrightarrow> Suc (Suc n) \<le> card U
[PROOF STEP]
with n_nnvs_unvis.IH[OF n_nnvs_unvis.hyps(2)]
[PROOF STATE]
proof (chain)
picking this:
Suc n \<le> card U
card (insert (nearest_vert w u U) U) = Suc (card U)
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
using this:
Suc n \<le> card U
card (insert (nearest_vert w u U) U) = Suc (card U)

goal (1 subgoal):
 1. Suc (Suc n) \<le> card (insert (nearest_vert w u U) U)
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
Suc (Suc n) \<le> card (insert (nearest_vert w u U) U)

goal (2 subgoals):
 1. \<And>u _. \<lbrakk>u \<in> verts G; unvisited_verts u {u} \<noteq> {}\<rbrakk> \<Longrightarrow> Suc 0 \<le> card {u}
 2. \<And>w u n U. \<lbrakk>n_nearest_verts w u n U; unvisited_verts u U \<noteq> {} \<Longrightarrow> Suc n \<le> card U; unvisited_verts u U = {}; unvisited_verts u U \<noteq> {}\<rbrakk> \<Longrightarrow> Suc (Suc n) \<le> card U
[PROOF STEP]
qed simp_all


[STATEMENT]
lemma size_ok_steps: "\<lbrakk>
  invar states;
   n < remaining_steps states;
  size_ok' states (remaining_steps states - n)
\<rbrakk> \<Longrightarrow> size_ok ((step ^^ n) states)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<lbrakk>invar states; n < remaining_steps states; size_ok' states (remaining_steps states - n)\<rbrakk> \<Longrightarrow> size_ok ((step ^^ n) states)
[PROOF STEP]
by (simp add: step_n_size_ok')


[STATEMENT]
lemma mult_two_impl2[dest]:
  assumes "a * 2 = 1 + 2 * b"
  shows "(a::enat) = \<infinity> \<and> b=\<infinity>"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. a = \<infinity> \<and> b = \<infinity>
[PROOF STEP]
apply(cases a;cases b)
[PROOF STATE]
proof (prove)
goal (4 subgoals):
 1. \<And>nat nata. \<lbrakk>a = enat nat; b = enat nata\<rbrakk> \<Longrightarrow> a = \<infinity> \<and> b = \<infinity>
 2. \<And>nat. \<lbrakk>a = enat nat; b = \<infinity>\<rbrakk> \<Longrightarrow> a = \<infinity> \<and> b = \<infinity>
 3. \<And>nat. \<lbrakk>a = \<infinity>; b = enat nat\<rbrakk> \<Longrightarrow> a = \<infinity> \<and> b = \<infinity>
 4. \<lbrakk>a = \<infinity>; b = \<infinity>\<rbrakk> \<Longrightarrow> a = \<infinity> \<and> b = \<infinity>
[PROOF STEP]
using assms Suc_double_not_eq_double[unfolded mult_2, symmetric]
[PROOF STATE]
proof (prove)
using this:
a * 2 = 1 + 2 * b
?n + ?n \<noteq> Suc (?m + ?m)

goal (4 subgoals):
 1. \<And>nat nata. \<lbrakk>a = enat nat; b = enat nata\<rbrakk> \<Longrightarrow> a = \<infinity> \<and> b = \<infinity>
 2. \<And>nat. \<lbrakk>a = enat nat; b = \<infinity>\<rbrakk> \<Longrightarrow> a = \<infinity> \<and> b = \<infinity>
 3. \<And>nat. \<lbrakk>a = \<infinity>; b = enat nat\<rbrakk> \<Longrightarrow> a = \<infinity> \<and> b = \<infinity>
 4. \<lbrakk>a = \<infinity>; b = \<infinity>\<rbrakk> \<Longrightarrow> a = \<infinity> \<and> b = \<infinity>
[PROOF STEP]
by (auto simp add: mult_2 one_enat_def mult_2_right)


[STATEMENT]
lemma two_comparisons_into_case_order:
  "(if le x y then (if x = y then P else Q) else R) = (case_order P Q R (comp x y))"
  "(if le x y then (if y = x then P else Q) else R) = (case_order P Q R (comp x y))"
  "(if le x y then (if le y x then P else Q) else R) = (case_order P Q R (comp x y))"
  "(if le x y then (if lt x y then Q else P) else R) = (case_order P Q R (comp x y))"
  "(if lt x y then Q else (if le x y then P else R)) = (case_order P Q R (comp x y))"
  "(if lt x y then Q else (if lt y x then R else P)) = (case_order P Q R (comp x y))"
  "(if lt x y then Q else (if x = y then P else R)) = (case_order P Q R (comp x y))"
  "(if lt x y then Q else (if y = x then P else R)) = (case_order P Q R (comp x y))"
  "(if x = y then P else (if lt y x then R else Q)) = (case_order P Q R (comp x y))"
  "(if x = y then P else (if lt x y then Q else R)) = (case_order P Q R (comp x y))"
  "(if x = y then P else (if le y x then R else Q)) = (case_order P Q R (comp x y))"
  "(if x = y then P else (if le x y then Q else R)) = (case_order P Q R (comp x y))"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (((if le x y then if x = y then P else Q else R) = (case comp x y of Eq \<Rightarrow> P | Lt \<Rightarrow> Q | Gt \<Rightarrow> R) &&& (if le x y then if y = x then P else Q else R) = (case comp x y of Eq \<Rightarrow> P | Lt \<Rightarrow> Q | Gt \<Rightarrow> R) &&& (if le x y then if le y x then P else Q else R) = (case comp x y of Eq \<Rightarrow> P | Lt \<Rightarrow> Q | Gt \<Rightarrow> R)) &&& (if le x y then if lt x y then Q else P else R) = (case comp x y of Eq \<Rightarrow> P | Lt \<Rightarrow> Q | Gt \<Rightarrow> R) &&& (if lt x y then Q else if le x y then P else R) = (case comp x y of Eq \<Rightarrow> P | Lt \<Rightarrow> Q | Gt \<Rightarrow> R) &&& (if lt x y then Q else if lt y x then R else P) = (case comp x y of Eq \<Rightarrow> P | Lt \<Rightarrow> Q | Gt \<Rightarrow> R)) &&& ((if lt x y then Q else if x = y then P else R) = (case comp x y of Eq \<Rightarrow> P | Lt \<Rightarrow> Q | Gt \<Rightarrow> R) &&& (if lt x y then Q else if y = x then P else R) = (case comp x y of Eq \<Rightarrow> P | Lt \<Rightarrow> Q | Gt \<Rightarrow> R) &&& (if x = y then P else if lt y x then R else Q) = (case comp x y of Eq \<Rightarrow> P | Lt \<Rightarrow> Q | Gt \<Rightarrow> R)) &&& (if x = y then P else if lt x y then Q else R) = (case comp x y of Eq \<Rightarrow> P | Lt \<Rightarrow> Q | Gt \<Rightarrow> R) &&& (if x = y then P else if le y x then R else Q) = (case comp x y of Eq \<Rightarrow> P | Lt \<Rightarrow> Q | Gt \<Rightarrow> R) &&& (if x = y then P else if le x y then Q else R) = (case comp x y of Eq \<Rightarrow> P | Lt \<Rightarrow> Q | Gt \<Rightarrow> R)
[PROOF STEP]
by (auto simp: le_lt_convs split: order.splits)


[STATEMENT]
lemma mult_ge1_mono [mono_intros]:
  assumes "a \<ge> (0::'a::linordered_idom)" "b \<ge> 1"
  shows "a \<le> a * b" "a \<le> b * a"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. a \<le> a * b &&& a \<le> b * a
[PROOF STEP]
using assms mult_le_cancel_left1 mult_le_cancel_right1
[PROOF STATE]
proof (prove)
using this:
(0::'a) \<le> a
(1::'a) \<le> b
(?c \<le> ?c * ?b) = (((0::?'a) < ?c \<longrightarrow> (1::?'a) \<le> ?b) \<and> (?c < (0::?'a) \<longrightarrow> ?b \<le> (1::?'a)))
(?c \<le> ?b * ?c) = (((0::?'a) < ?c \<longrightarrow> (1::?'a) \<le> ?b) \<and> (?c < (0::?'a) \<longrightarrow> ?b \<le> (1::?'a)))

goal (1 subgoal):
 1. a \<le> a * b &&& a \<le> b * a
[PROOF STEP]
by force+


[STATEMENT]
lemma Pm_fmap_sum: "Pm_fmap f = (\<Sum>x \<in> fmdom' f. monomial (lookup0 f x) x)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. Pm_fmap f = (\<Sum>x\<in>fmdom' f. monomial (lookup0 f x) x)
[PROOF STEP]
including fmap.lifting
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. Pm_fmap f = (\<Sum>x\<in>fmdom' f. monomial (lookup0 f x) x)
[PROOF STEP]
by (auto intro!: poly_mapping_eqI sum.neutral
      simp: fmlookup_default_def lookup_sum lookup_single when_def fmdom'I
      split: option.splits)


[STATEMENT]
lemma comp_MkArr [simp]:
    assumes "arr (MkArr A B F)" and "arr (MkArr B C G)"
    shows "COMP (MkArr B C G) (MkArr A B F) = MkArr A C (Comp C B A G F)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. COMP (MkArr B C G) (MkArr A B F) = MkArr A C (Comp C B A G F)
[PROOF STEP]
using assms comp_char [of "MkArr B C G" "MkArr A B F"]
[PROOF STATE]
proof (prove)
using this:
arr (MkArr A B F)
arr (MkArr B C G)
COMP (MkArr B C G) (MkArr A B F) = (if seq (MkArr B C G) (MkArr A B F) then MkArr (Dom (MkArr A B F)) (Cod (MkArr B C G)) (Comp (Cod (MkArr B C G)) (Dom (MkArr B C G)) (Dom (MkArr A B F)) (Map (MkArr B C G)) (Map (MkArr A B F))) else null)

goal (1 subgoal):
 1. COMP (MkArr B C G) (MkArr A B F) = MkArr A C (Comp C B A G F)
[PROOF STEP]
by simp


[STATEMENT]
lemma in_real_itvl_get_bounds_tighten: "real_of_3 x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ n) x)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. real_of_3 x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ n) x)
[PROOF STEP]
proof (induct n arbitrary: x)
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<And>x. real_of_3 x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ 0) x)
 2. \<And>n x. (\<And>x. real_of_3 x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ n) x)) \<Longrightarrow> real_of_3 x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ Suc n) x)
[PROOF STEP]
case 0
[PROOF STATE]
proof (state)
this:

goal (2 subgoals):
 1. \<And>x. real_of_3 x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ 0) x)
 2. \<And>n x. (\<And>x. real_of_3 x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ n) x)) \<Longrightarrow> real_of_3 x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ Suc n) x)
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. real_of_3 x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ 0) x)
[PROOF STEP]
using get_itvl_3[of x]
[PROOF STATE]
proof (prove)
using this:
real_of_3 x \<in>\<^sub>i get_itvl_3 x

goal (1 subgoal):
 1. real_of_3 x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ 0) x)
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
real_of_3 x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ 0) x)

goal (1 subgoal):
 1. \<And>n x. (\<And>x. real_of_3 x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ n) x)) \<Longrightarrow> real_of_3 x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ Suc n) x)
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>n x. (\<And>x. real_of_3 x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ n) x)) \<Longrightarrow> real_of_3 x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ Suc n) x)
[PROOF STEP]
case (Suc n x)
[PROOF STATE]
proof (state)
this:
real_of_3 ?x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ n) ?x)

goal (1 subgoal):
 1. \<And>n x. (\<And>x. real_of_3 x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ n) x)) \<Longrightarrow> real_of_3 x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ Suc n) x)
[PROOF STEP]
have id: "(tighten_bounds_3 ^^ (Suc n)) x = (tighten_bounds_3 ^^ n) (tighten_bounds_3 x)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (tighten_bounds_3 ^^ Suc n) x = (tighten_bounds_3 ^^ n) (tighten_bounds_3 x)
[PROOF STEP]
by (metis comp_apply funpow_Suc_right)
[PROOF STATE]
proof (state)
this:
(tighten_bounds_3 ^^ Suc n) x = (tighten_bounds_3 ^^ n) (tighten_bounds_3 x)

goal (1 subgoal):
 1. \<And>n x. (\<And>x. real_of_3 x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ n) x)) \<Longrightarrow> real_of_3 x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ Suc n) x)
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. real_of_3 x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ Suc n) x)
[PROOF STEP]
unfolding id tighten_bounds_3(1)[of x, symmetric]
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. real_of_3 (tighten_bounds_3 x) \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ n) (tighten_bounds_3 x))
[PROOF STEP]
by (rule Suc)
[PROOF STATE]
proof (state)
this:
real_of_3 x \<in>\<^sub>i get_itvl_3 ((tighten_bounds_3 ^^ Suc n) x)

goal:
No subgoals!
[PROOF STEP]
qed