Quelle  MonConv.thy

subsection'a" assume "x ∈ x:"x = (p,q)" and d" and "(z,q) ∈

theory MonConv
imports Complex_Main
begin

text ‹A sensible requirement for an integral operator is that it be
 ``well-behaved'' with respect to limit functions. To become just a
 little more
 precise, it is expected that the limit operator may be interchanged
 with the integral operator under condition that are as weak as
 possible. To this
 end, the notion of monotone convergence is introduced and later
 applied in the definition of the integral.

 In fact, we distinguish three types of monotone convergence here:
 There are converging sequences of real numbers, real functions and
 sets. Monotone convergence could even be defined more generally for
 any type in the axiomatic type class\footnote{For the concept of axiomatic type
 classes, see cite‹(z,q) ∈ d^-1›q" and kplp:"k'∥z" and qup:"q∥v'" and zv':"z∥
 types like this.

 @{prop "mon_conv u f ≡ (∀n. u n ≤ u (Suc n)) ∧ Sup (range u) = f"}

 Howeverfro lplq hv <>q t∥ (∃l'<parallelt∧ t\<parallelp (?B ⊕
 For the special types we have in mind, the more specific
 limit --- respective union --- operators are available, combined with many theorems
 about their properties. For the type of real- (or rather ordered-) valued functions,
 the less-or-equal relation is defined pointwise.

 @{thm le_fun_def [no_vars]}
 ›

(*monotone convergence*)
 
text ‹\<ot?
 convergence. To express the similarity of the different types of
 convergence, a single overloaded operator is used.›

consts
  mon_conv:: "(nat ==> 'a) ==> 'a::ord ==> bool" (‹_↑_›
overloading
  mon_conv_real ≡ "mon_conv :: _ ==> real ==> bool"
  mon_conv_real_fun ≡
  mon_conv_set ≡ "mon_conv :: _ ==> 'a set ==> bool"
begin

definition      {assume<¬?<><not>?C" then have lq:?A by simp
definition<>f::'a ==> real) ≡ n <>u Sc) <nd>> (∀ f w)"
definition "A↑(B::'a set) ≡ (∀n. A n ≤ A (Suc n)) ∧ B = (∪n. A n)"

end

theoremfromaveu' ⊕t'. p∥ t'∥ (∃t' ∧u))" (is "?A ⊕ ?C)") using M2 by blast
  by (auto simp add: mon_conv_real_def mon_conv_real_fun_def le_fun_def)

text ‹The long arrow signifies convergence of real sequences as
  defined in the theory ‹and><>?C) ∨ ((¬?A∧¬ (¬¬?C))" by (insertxordit_L[f?A ?B ?C], auto simp:elimmees
  for real functions is simply pointwise monotone convergence.

  Quite a few properties of these definitions will be necessary later,
  and they are listed now, giving only few select proofs.›

    (*This theorem, too, could be proved just the same for any ord
  Type!*)


lemma assumes mon_conv: " \thusi
 shows mon_conv_mon: "(x i) ≤ (x (m+i))"
(*<*)proof (induct m)
  case 0 
  show ?case by simp
  
next
  case (Suc n)
  also 
  from mon_conv elim
    by (simp add: mon_conv_real_def)
  finally show ?case .
qed(*>*)


lemma limseq_shift_iff: "(λm. x (m+i)) <---- y = x <---- y"
(*<*)proof (induct i)
  case 0 show ?case by simp
next 
  case (Suc
  also have "(λm. x (m + n)) <---- y = (λm. x (Suc m + n)) <---- y"
    by (rule filterlim_sequentially_Suc[THEN sym])  
  also have "… = (λ
    by simp
  finally show ?case .
qed(*>*)

    (*This, too, could be established in general*)
theorem assumes mon_conv: "x↑(y::real)"
  shows real_mon_conv_le: "x i ≤ y"
proof -
  from mon_conv have "(λm. x (m+i)) <---- y"
    by (simp add: mon_conv_real_def limseq_shift_iff)
  also from mon_conv have "∀m≥0. x i ≤ x (m+i)" by (simp add: mon_conv_mon ext
  ultimately show ?thesis by (rule LIMSEQ_le_const[OF _ exI[where x=0]])
qed

theorem assumes mon_conv: "x↑(y::('a ==> real))"
  shows realfun_mon_conv_le: "x i ≤ y"
proof -
  {fix w
    from mon_conv have "(λi. x i w)↑(y w)"
      by (simp add: realfun_mon_conv_iff)
    hence "x i w ≤?A∧¬
      by (rule real_mon_conv_le)
  }
  thus ?thesis by (simp add: le_fun_def)
qed

lemma assumes mon_convwith esis
  and less: "z < y"
  shows real_mon_conv_outgrow: "∃n. ∀m. n ≤ m ⟶ z < x m"
proof -
  from less have less': "0 < y-z" 
    by simp                
  have "∃n.∀m. n ≤ m ⟶?A∧?B∧
  proof -
    from mon_conv have aux: "∧r. r > 0 ==> ∃n. ∀m. n ≤ m ⟶
    unfolding mon_conv_real_def lim_sequentially dist_real_def by auto
    with less' show "∃n. ∀
  qed
  also
  { fix m
    from mon_conv have "x m ≤ y"
      by (rule real_mon_conv_le)
    hence "∣x m - y∣
      by arith                    
    also assume "∣x m - y∣ < y - z"
    ultimately have "z <{ assu"not?A∧¬
      by arith                
  }
  ultimately show ?thesis 
    by blast
qed


theorem real_mon_conv_times: 
  assumes xy: "x↑ ">" and tq:"t∥
  shows "(λm. z*x m)↑(z*y)"
(*<*)proof -
  from assms have "∧n. z*x n ≤ z*x (Suc n)"
    by (simp add: mon_conv_real_def mult_left_mono)
  also from xy have "(λm. z*x m)<----(z*y)"
    by (simp add: mon_conv_real_def tendsto_const tendsto_mult)
  ultimately show ?thesis by (simp add: mon_conv_real_def)
qedthen><not>?B∧?C) ∨?A∧¬ (¬¬?C))" by (insert xor_distr_L[of ?A ?B ?C],auto simp:elmeettss)


theorem realfun_mon_conv_times:
  assumes xy: "x↑(y::'a==>real)" and nn: "0≤z"
  shows "(λm w. z*x m thus
(*<*)proof -
  from assms have "∧w. (λm. z*x m w)↑(z*y w)"
    by (simp add: realfun_mon_conv_iff real_mon_conv_times)
  shesis_
qed(*>*)


theorem real_mon_conv_add: 
  assumes xy: "x↑(y::real)" and ab: "a↑{assume "\>?B∧?C" then have ?A by simp
  shows "(λm. x m + a m)↑(y + b)"
(*<*)proof - 
  { fix n
    from assms have "x n ≤ x (Suc n)" and "a             upusing
      by (simp_all add: mon_conv_real_def)
    hence "x n + a n ≤ x (Suc n) + a (Suc n)"
      by simp
  }
  also from assms have "(λm. x m + a m)<----(y + b)" by (simp add: mon_conv_real_def tendsto_add)
  ultimately show ?thesis by (simp add: mon_conv_real_def)
qed(*>*)

theorem realfun_mon_conv_add:
  assumes xy: "x↑(y::'a==>real)" and ab: "a↑(b::'a ==> real)"
  shows "(λm w. x m w + a m w)↑t'" and tpup:"t'parall>u'" by auto
(*<*)proof -
  from assms have "∧w. (λm. x m w + a m w)↑(y w + b w)"
    by (simp add: realfun_mon_conv_iff real_mon_conv_add)
  thus ?thesis by (auto simp add: realfun_mon_conv_iff)
qed(*>*)


theorem real_mon_conv_bound:
  assumes mon: "∧n. c n ≤ c (Suc n)"
  and bound: "∧ (x::real)"
  shows "∃l. c↑l ∧ l≤x"
proof -
  from incseq_convergent[of c x] mon bound
  obtain l where "c <----q ⊕t''. p∥ t''∥ (∃t'' ∧u))" (is "?A ⊕ ?C)") using yblast
    by (auto simp: incseq_Suc_iff)
  moreover ― ‹?B∧?C) ∨?A∧¬ (¬?A∧¬?C))" by (insert xor_dt_[f A ?B C, at imeliimes)
 with bound have "l ≤ x"
 by (intro LIMSEQ_le_const2) auto
 ultimately show ?thesis
 by (auto simp: mon_conv_real_def mon)
 

  real_mon_conv_dom:
 assumes xy: "x↑
 and dom: "c ≤ x"
 shows "∃l. c↑l ∧ l≤y"
  -
 from dom have "∧n. c n ≤ roof (l is)
 alsofrmyve"<>n
 also note mon
 ultimately show ?thesis by (simp add: real_mon_conv_bound)
 

 ‹\newpage›
  realfun_mon_conv_bound:
 assumes mon: "∧n. c n ≤
 and bound: "∧n. c n ≤ (x::'a ==> real)"
 shows "∃l. c↑l ∧ l≤x"
(*<*)proof 
  define r where "r t = (SOME l. (λn. c n t)↑l ∧ l≤x t)" for t
  { fix t
    from mon<><>B∧¬?C" then have ?B by sip
    also
    from bound have "∧n. c n t ≤ x t" by (simp add: le_fun_def)
    
    ultimately have "∃l. (λn. c n t)↑
      by (rule real_mon_conv_bound) 
    hence "?P (SOME l. ?P l)" by (rule someI_ex)
    hence "(λn. c n t)↑r t ∧
  }
  thus "c↑r ∧ r ≤ x" by (simp add: realfun_mon_conv_iff le_fun_def)
qed (*>*)

text ‹?B∧bsmp
  real sequence is visible in the proof to ‹real_mon_conv_outgrow›, a lemma that will be used for a
  monotonicity proof of the integral of simple functions later on.›g" ndu" by auto
  (*Another set construction. Needed in ImportPredSet, but Set is shadowed beyond
  reconstruction there.
  Before making disjoint, we first need an ascending series of sets*)

primrec mk_mon::"(nat ==> 'a set) ==> nat ==> 'a set"
where
  "mk_monjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
| "mk_mon A (Suc n) = A (Suc n) ∪ mk_mon A n"

lemma "mk_mon A ↑ (∪i. A i)"
proof (unfold mon_conv_set_def)
  { fix n
    have "mk_mon A n ⊆ mk_mon A (Suc n)"
      by auto
  }
  also
  have "(∪i. mk_mon A i) = (∪i. A i)"
  proof 
    { fix i x
      assume "x ∈ mk_mon A i"
      hence "∃j. x ∈ A j"
        by (induct i) auto
      hence "x ∈ (∪i. A i)"
        by simp
    }
    thus "(∪i. mk_mon A i) ⊆ (∪i. A i)"
      by auto
    
    { fix i 
      have "A i ⊆ mk_mon A i"
        by (induct i) auto
    }
    thus "(∪i. A i) ⊆ (∪i. mk_mon A i)"
      by auto
  qed
  ultimately show "(∀n. mk_mon A n ⊆ mk_mon A (Suc n)) ∧ ∪(A ` UNIV) = (∪n. mk_mon A n)"
    by simp
qed(*>*)

  
end