openAI-math-dataset / lean /OAI /MathematicalPhysics /Boltzmann /Approximation /PositiveIntegralFixedPoint.lean
| import OAI.MathematicalPhysics.Boltzmann.Branching.BoundedCollisionBlocks | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.WeakL1ToWeakStar | |
| import Mathlib.MeasureTheory.Integral.Prod | |
| namespace OAI | |
| section | |
| /-! # Positive integral contraction along measurable characteristics | |
| This lemma constructs a fixed point of a bounded positive source map. | |
| The collision source and its quantitative estimates are supplied separately. | |
| -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open scoped Topology | |
| namespace BoltzmannNonuniqueness.PositiveIntegral | |
| variable {P : Type*} [MeasurableSpace P] | |
| abbrev Domain (P : Type*) := ℝ × P | |
| def time (T t : ℝ) : ℝ := max 0 (min T t) | |
| theorem time_bounds {T : ℝ} (hT : 0 ≤ T) (t : ℝ) : | |
| 0 ≤ time T t ∧ time T t ≤ T := | |
| ⟨le_max_left _ _, max_le hT (min_le_left _ _)⟩ | |
| def value (T L : ℝ) (flow : ℝ → P → P) (f₀ : P → ℝ) | |
| (g : Domain P → ℝ) (z : Domain P) : ℝ := | |
| Real.exp (-L * time T z.1) * f₀ (flow (-time T z.1) z.2) + | |
| ∫ r in 0..time T z.1, | |
| Real.exp (-L * (time T z.1 - r)) * g (r, flow (r - time T z.1) z.2) | |
| theorem measurable_value {T L : ℝ} (hT : 0 ≤ T) {flow : ℝ → P → P} | |
| (hflow : Measurable (fun z : ℝ × P => flow z.1 z.2)) | |
| {f₀ : P → ℝ} (hf₀ : Measurable f₀) {g : Domain P → ℝ} (hg : Measurable g) : | |
| Measurable (value T L flow f₀ g) := by | |
| have ht : Measurable (fun z : Domain P => time T z.1) := by unfold time; fun_prop | |
| have hm : Measurable (fun z : Domain P => | |
| ∫ r : ℝ, if 0 < r ∧ r ≤ time T z.1 then | |
| Real.exp (-L * (time T z.1 - r)) * g (r, flow (r - time T z.1) z.2) else 0) := by | |
| apply StronglyMeasurable.measurable | |
| apply StronglyMeasurable.integral_prod_right | |
| apply Measurable.stronglyMeasurable | |
| have hfl : Measurable (fun q : Domain P × ℝ => flow (q.2 - time T q.1.1) q.1.2) := | |
| hflow.comp ((measurable_snd.sub (ht.comp measurable_fst)).prodMk measurable_fst.snd) | |
| apply Measurable.ite | |
| · exact (measurableSet_lt measurable_const measurable_snd).inter | |
| (measurableSet_le measurable_snd (ht.comp measurable_fst)) | |
| · have he : Measurable (fun q : Domain P × ℝ => Real.exp (-L * (time T q.1.1 - q.2))) := by | |
| unfold time | |
| fun_prop | |
| exact he.mul (hg.comp (measurable_snd.prodMk hfl)) | |
| · exact measurable_const | |
| have he (z : Domain P) : (∫ r in 0..time T z.1, | |
| Real.exp (-L * (time T z.1 - r)) * g (r, flow (r - time T z.1) z.2)) = | |
| ∫ r : ℝ, if 0 < r ∧ r ≤ time T z.1 then | |
| Real.exp (-L * (time T z.1 - r)) * g (r, flow (r - time T z.1) z.2) else 0 := by | |
| rw [intervalIntegral.integral_of_le (time_bounds hT z.1).1, ← integral_indicator measurableSet_Ioc] | |
| apply integral_congr_ae | |
| exact ae_of_all _ (fun r => by simp only [Set.indicator_apply, Set.mem_Ioc]) | |
| unfold value | |
| simp_rw [he] | |
| have he : Measurable (fun z : Domain P => Real.exp (-L * time T z.1)) := by | |
| unfold time | |
| fun_prop | |
| exact (he.mul (hf₀.comp (hflow.comp ((ht.neg).prodMk measurable_snd)))).add hm | |
| omit [MeasurableSpace P] in | |
| theorem value_bounds {T L A S : ℝ} (hT : 0 ≤ T) (hL : 0 ≤ L) (_hA : 0 ≤ A) | |
| (hS : 0 ≤ S) (flow : ℝ → P → P) {f₀ : P → ℝ} | |
| (hf₀ : ∀ p, 0 ≤ f₀ p ∧ f₀ p ≤ A) {g : Domain P → ℝ} | |
| (hg : ∀ z, 0 ≤ g z ∧ g z ≤ S) | |
| (z : Domain P) : 0 ≤ value T L flow f₀ g z ∧ value T L flow f₀ g z ≤ A + T * S := by | |
| have ht := time_bounds hT z.1 | |
| have he (r : ℝ) (hr : r ∈ Icc 0 (time T z.1)) : | |
| 0 ≤ Real.exp (-L * (time T z.1 - r)) ∧ Real.exp (-L * (time T z.1 - r)) ≤ 1 := by | |
| exact ⟨(Real.exp_pos _).le, Real.exp_le_one_iff.mpr (by nlinarith [hr.2])⟩ | |
| have hi : (∫ r in 0..time T z.1, | |
| Real.exp (-L * (time T z.1 - r)) * g (r, flow (r - time T z.1) z.2)) ≤ S * time T z.1 := by | |
| apply (le_abs_self _).trans | |
| have h := intervalIntegral.norm_integral_le_of_norm_le_const (a := 0) | |
| (b := time T z.1) (C := S) (f := fun r => | |
| Real.exp (-L * (time T z.1 - r)) * g (r, flow (r - time T z.1) z.2)) | |
| (fun r hr => by | |
| rw [uIoc_of_le ht.1] at hr | |
| rw [Real.norm_eq_abs, abs_of_nonneg (mul_nonneg (Real.exp_pos _).le (hg _).1)] | |
| exact (mul_le_mul_of_nonneg_right (he r ⟨hr.1.le, hr.2⟩).2 (hg _).1).trans | |
| (by simpa using (hg _).2)) | |
| simpa only [Real.norm_eq_abs, sub_zero, abs_of_nonneg ht.1] using h | |
| constructor | |
| · exact add_nonneg (mul_nonneg (Real.exp_pos _).le (hf₀ _).1) | |
| (intervalIntegral.integral_nonneg ht.1 (fun r _ => mul_nonneg (Real.exp_pos _).le (hg _).1)) | |
| · have hinit : Real.exp (-L * time T z.1) * f₀ (flow (-time T z.1) z.2) ≤ A := | |
| (mul_le_mul_of_nonneg_right (Real.exp_le_one_iff.mpr (by nlinarith)) (hf₀ _).1).trans | |
| (by simpa using (hf₀ _).2) | |
| exact (add_le_add hinit hi).trans (by nlinarith) | |
| theorem damped_integrable {T L S : ℝ} (hT : 0 ≤ T) (hL : 0 ≤ L) | |
| {flow : ℝ → P → P} (hflow : Measurable (fun z : ℝ × P => flow z.1 z.2)) | |
| {g : Domain P → ℝ} (hgm : Measurable g) (hg : ∀ z, |g z| ≤ S) | |
| (z : Domain P) : IntervalIntegrable (fun r => | |
| Real.exp (-L * (time T z.1 - r)) * g (r, flow (r - time T z.1) z.2)) volume 0 (time T z.1) := by | |
| apply (intervalIntegrable_const (c := S)).mono_fun' | |
| · have hm : Measurable (fun r : ℝ => flow (r - time T z.1) z.2) := | |
| hflow.comp ((measurable_id.sub measurable_const).prodMk measurable_const) | |
| have he : Measurable (fun r : ℝ => Real.exp (-L * (time T z.1 - r))) := by fun_prop | |
| exact (he.mul (hgm.comp (measurable_id.prodMk hm))).aestronglyMeasurable | |
| · filter_upwards [ae_restrict_mem measurableSet_uIoc] with r hr | |
| rw [uIoc_of_le (time_bounds hT z.1).1] at hr | |
| rw [Real.norm_eq_abs, abs_mul, abs_of_pos (Real.exp_pos _)] | |
| have he : Real.exp (-L * (time T z.1 - r)) ≤ 1 := | |
| Real.exp_le_one_iff.mpr (by nlinarith [hr.2]) | |
| exact (mul_le_mul_of_nonneg_right he (abs_nonneg _)).trans (by simpa using hg _) | |
| theorem value_difference {T L S D : ℝ} (hT : 0 ≤ T) (hL : 0 ≤ L) (hD : 0 ≤ D) | |
| {flow : ℝ → P → P} (hflow : Measurable (fun z : ℝ × P => flow z.1 z.2)) | |
| (f₀ : P → ℝ) {g h : Domain P → ℝ} (hgm : Measurable g) (hhm : Measurable h) | |
| (hg : ∀ z, |g z| ≤ S) (hh : ∀ z, |h z| ≤ S) (hgh : ∀ z, |g z - h z| ≤ D) | |
| (z : Domain P) : |value T L flow f₀ g z - value T L flow f₀ h z| ≤ T * D := by | |
| have ht := time_bounds hT z.1 | |
| have hgi := damped_integrable hT hL hflow hgm hg z | |
| have hhi := damped_integrable hT hL hflow hhm hh z | |
| unfold value | |
| rw [add_sub_add_left_eq_sub, ← intervalIntegral.integral_sub hgi hhi] | |
| have hb := intervalIntegral.norm_integral_le_of_norm_le_const (a := 0) (b := time T z.1) | |
| (C := D) (f := fun r => | |
| Real.exp (-L * (time T z.1 - r)) * g (r, flow (r - time T z.1) z.2) - | |
| Real.exp (-L * (time T z.1 - r)) * h (r, flow (r - time T z.1) z.2)) | |
| (fun r hr => by | |
| rw [uIoc_of_le ht.1] at hr | |
| rw [← mul_sub, Real.norm_eq_abs, abs_mul, abs_of_pos (Real.exp_pos _)] | |
| have he : Real.exp (-L * (time T z.1 - r)) ≤ 1 := | |
| Real.exp_le_one_iff.mpr (by nlinarith [hr.2]) | |
| exact (mul_le_mul_of_nonneg_right he (abs_nonneg _)).trans (by simpa using hgh _)) | |
| rw [Real.norm_eq_abs, sub_zero, abs_of_nonneg ht.1] at hb | |
| exact hb.trans (by nlinarith) | |
| /-- Positive Picard iteration converges in the complete sup-norm space. -/ | |
| theorem exists_fixed_point {T L A R S K : ℝ} (hT : 0 ≤ T) (hL : 0 ≤ L) | |
| (hA : 0 ≤ A) (hR : 0 ≤ R) (hS : 0 ≤ S) (hK : 0 ≤ K) | |
| (hball : A + T * S ≤ R) (hsmall : T * K < 1) | |
| {flow : ℝ → P → P} (hflow : Measurable (fun z : ℝ × P => flow z.1 z.2)) | |
| {f₀ : P → ℝ} (hf₀m : Measurable f₀) (hf₀ : ∀ p, 0 ≤ f₀ p ∧ f₀ p ≤ A) | |
| (source : BoundedMeasurable.PositiveBall (Domain P) R → Domain P → ℝ) | |
| (hsm : ∀ f, Measurable (source f)) | |
| (hsb : ∀ f z, 0 ≤ source f z ∧ source f z ≤ S) | |
| (hsl : ∀ f g z, |source f z - source g z| ≤ K * dist f g) : | |
| ∃ f : BoundedMeasurable.PositiveBall (Domain P) R, | |
| ∀ z, f.val z = value T L flow f₀ (source f) z := by | |
| let step : BoundedMeasurable.PositiveBall (Domain P) R → | |
| BoundedMeasurable.PositiveBall (Domain P) R := fun f => | |
| ⟨BoundedMeasurable.ofBounded (Domain P) (value T L flow f₀ (source f)) | |
| (measurable_value hT hflow hf₀m (hsm f)) (A + T * S) | |
| (fun z => by | |
| rw [abs_of_nonneg (value_bounds hT hL hA hS flow hf₀ (hsb f) z).1] | |
| exact (value_bounds hT hL hA hS flow hf₀ (hsb f) z).2), | |
| fun z => ⟨(value_bounds hT hL hA hS flow hf₀ (hsb f) z).1, | |
| (value_bounds hT hL hA hS flow hf₀ (hsb f) z).2.trans hball⟩⟩ | |
| have hc : ContractingWith ⟨T * K, mul_nonneg hT hK⟩ step := by | |
| constructor | |
| · exact hsmall | |
| · apply LipschitzWith.of_dist_le_mul | |
| intro f g | |
| change dist (step f).val (step g).val ≤ (T * K) * dist f g | |
| apply BoundedMeasurable.dist_le (Domain P) (by positivity) | |
| intro z | |
| have h := value_difference hT hL (mul_nonneg hK dist_nonneg) hflow f₀ | |
| (hsm f) (hsm g) | |
| (fun z => by rw [abs_of_nonneg (hsb f z).1]; exact (hsb f z).2) | |
| (fun z => by rw [abs_of_nonneg (hsb g z).1]; exact (hsb g z).2) | |
| (hsl f g) z | |
| simpa only [step, BoundedMeasurable.ofBounded_apply, mul_assoc] using h | |
| let zero : BoundedMeasurable.PositiveBall (Domain P) R := | |
| ⟨BoundedMeasurable.ofBounded (Domain P) (fun _ => 0) measurable_const 0 | |
| (fun _ => by simp), fun _ => ⟨le_rfl, hR⟩⟩ | |
| let : Nonempty (BoundedMeasurable.PositiveBall (Domain P) R) := ⟨zero⟩ | |
| refine ⟨hc.fixedPoint, ?_⟩ | |
| intro z | |
| have he := congrArg (fun f : BoundedMeasurable.PositiveBall (Domain P) R => f.val z) | |
| hc.fixedPoint_isFixedPt | |
| exact he.symm | |
| end BoltzmannNonuniqueness.PositiveIntegral | |
| end | |
| end | |
| section | |
| /-! # Order and dominated convergence for positive characteristic integrals -/ | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped Topology | |
| namespace BoltzmannNonuniqueness.PositiveIntegral | |
| variable {P : Type*} [MeasurableSpace P] | |
| theorem value_mono {T L S : ℝ} (hT : 0 ≤ T) (hL : 0 ≤ L) | |
| {flow : ℝ → P → P} (hflow : Measurable (fun z : ℝ × P => flow z.1 z.2)) | |
| {f₀ k₀ : P → ℝ} (hfk : ∀ p, f₀ p ≤ k₀ p) | |
| {g h : Domain P → ℝ} (hgm : Measurable g) (hhm : Measurable h) | |
| (hg : ∀ z, |g z| ≤ S) (hh : ∀ z, |h z| ≤ S) (hgh : ∀ z, g z ≤ h z) | |
| (z : Domain P) : value T L flow f₀ g z ≤ value T L flow k₀ h z := by | |
| apply add_le_add | |
| · exact mul_le_mul_of_nonneg_left (hfk _) (Real.exp_pos _).le | |
| · apply intervalIntegral.integral_mono_on (time_bounds hT z.1).1 | |
| (damped_integrable hT hL hflow hgm hg z) (damped_integrable hT hL hflow hhm hh z) | |
| intro r _ | |
| exact mul_le_mul_of_nonneg_left (hgh _) (Real.exp_pos _).le | |
| theorem value_tendsto {T L S : ℝ} (hT : 0 ≤ T) (hL : 0 ≤ L) | |
| {flow : ℝ → P → P} (hflow : Measurable (fun z : ℝ × P => flow z.1 z.2)) | |
| (f₀ : P → ℝ) {g : ℕ → Domain P → ℝ} {h : Domain P → ℝ} | |
| (hgm : ∀ n, Measurable (g n)) (hg : ∀ n z, |g n z| ≤ S) | |
| (hlim : ∀ z, Tendsto (fun n => g n z) atTop (𝓝 (h z))) | |
| (z : Domain P) : Tendsto (fun n => value T L flow f₀ (g n) z) atTop | |
| (𝓝 (value T L flow f₀ h z)) := by | |
| apply tendsto_const_nhds.add | |
| apply intervalIntegral.tendsto_integral_filter_of_dominated_convergence (fun _ => S) | |
| · exact .of_forall (fun n => (damped_integrable hT hL hflow (hgm n) (hg n) z).def'.aestronglyMeasurable) | |
| · apply Eventually.of_forall | |
| intro n | |
| apply ae_of_all | |
| intro r hr | |
| rw [uIoc_of_le (time_bounds hT z.1).1] at hr | |
| rw [Real.norm_eq_abs, abs_mul, abs_of_pos (Real.exp_pos _)] | |
| have he : Real.exp (-L * (time T z.1 - r)) ≤ 1 := Real.exp_le_one_iff.mpr (by nlinarith [hr.2]) | |
| exact (mul_le_mul_of_nonneg_right he (abs_nonneg _)).trans (by simpa using hg n _) | |
| · exact intervalIntegrable_const | |
| · exact ae_of_all _ (fun r _ => tendsto_const_nhds.mul (hlim _)) | |
| end BoltzmannNonuniqueness.PositiveIntegral | |
| end | |
| end | |
| section | |
| /-! # Removing the auxiliary exponential weight from a mild solution -/ | |
| noncomputable section | |
| open Set | |
| namespace BoltzmannNonuniqueness.PositiveIntegral | |
| variable {P : Type*} | |
| theorem value_rescale {T : ℝ} (hT : 0 ≤ T) (a L : ℝ) (flow : ℝ → P → P) | |
| (f₀ : P → ℝ) (g : Domain P → ℝ) (z : Domain P) : | |
| Real.exp (a*time T z.1) * value T (a+L) flow f₀ | |
| (fun w => Real.exp (-a*time T w.1)*g w) z = value T L flow f₀ g z := by | |
| have ht := time_bounds hT z.1 | |
| have hi : Real.exp (a*time T z.1)*Real.exp (-(a+L)*time T z.1) = | |
| Real.exp (-L*time T z.1) := by | |
| rw [← Real.exp_add] | |
| congr 1 | |
| ring | |
| have he (r : ℝ) : Real.exp (a*time T z.1)*Real.exp (-(a+L)*(time T z.1-r))*Real.exp (-a*r) = | |
| Real.exp (-L*(time T z.1-r)) := by | |
| rw [← Real.exp_add,← Real.exp_add] | |
| congr 1 | |
| ring | |
| unfold value | |
| rw [mul_add,← mul_assoc,hi,← intervalIntegral.integral_const_mul] | |
| congr 1 | |
| apply intervalIntegral.integral_congr | |
| intro r hr | |
| rw [uIcc_of_le ht.1] at hr | |
| have hrT : r ≤ T := hr.2.trans ht.2 | |
| have hrt : time T r = r := by | |
| unfold time | |
| rw [min_eq_right hrT,max_eq_right hr.1] | |
| dsimp only | |
| rw [hrt] | |
| calc | |
| _ = (Real.exp (a*time T z.1)*Real.exp (-(a+L)*(time T z.1-r))*Real.exp (-a*r))* | |
| g (r,flow (r-time T z.1) z.2) := by ring | |
| _ = _ := by rw [he] | |
| end BoltzmannNonuniqueness.PositiveIntegral | |
| end | |
| end | |
| section | |
| /-! # Uniqueness on a common bounded interval for the positive integral map -/ | |
| noncomputable section | |
| open MeasureTheory | |
| namespace BoltzmannNonuniqueness.PositiveIntegral | |
| variable {P : Type*} [MeasurableSpace P] | |
| theorem fixed_point_unique {T L R S K : ℝ} (hT : 0 ≤ T) (hL : 0 ≤ L) (hK : 0 ≤ K) | |
| (hsmall : T * K < 1) | |
| {flow : ℝ → P → P} (hflow : Measurable (fun z : ℝ × P => flow z.1 z.2)) | |
| (f₀ : P → ℝ) | |
| (source : BoundedMeasurable.PositiveBall (Domain P) R → Domain P → ℝ) | |
| (hsm : ∀ f, Measurable (source f)) | |
| (hsb : ∀ f z, |source f z| ≤ S) | |
| (hsl : ∀ f g z, |source f z - source g z| ≤ K * dist f g) | |
| {f g : BoundedMeasurable.PositiveBall (Domain P) R} | |
| (hf : ∀ z, f.val z = value T L flow f₀ (source f) z) | |
| (hg : ∀ z, g.val z = value T L flow f₀ (source g) z) : f = g := by | |
| have hd : dist f g ≤ (T * K) * dist f g := by | |
| change dist f.val g.val ≤ _ | |
| apply BoundedMeasurable.dist_le (Domain P) (by positivity) | |
| intro z | |
| rw [hf, hg] | |
| have h := value_difference hT hL (mul_nonneg hK dist_nonneg) hflow f₀ | |
| (hsm f) (hsm g) (hsb f) (hsb g) (hsl f g) z | |
| simpa only [mul_assoc] using h | |
| have hz : dist f g = 0 := by nlinarith [dist_nonneg (x := f) (y := g)] | |
| exact dist_eq_zero.mp hz | |
| end BoltzmannNonuniqueness.PositiveIntegral | |
| end | |
| end | |
| section | |
| /-! # Dependence of the characteristic map on its initial value -/ | |
| noncomputable section | |
| open MeasureTheory | |
| namespace BoltzmannNonuniqueness.PositiveIntegral | |
| variable {P : Type*} [MeasurableSpace P] | |
| theorem value_difference_initial {T L S D I : ℝ} (hT : 0 ≤ T) (hL : 0 ≤ L) | |
| (hD : 0 ≤ D) (_hI : 0 ≤ I) | |
| {flow : ℝ → P → P} (hflow : Measurable (fun z : ℝ × P => flow z.1 z.2)) | |
| {f₀ k₀ : P → ℝ} (hfk : ∀ p, |f₀ p-k₀ p| ≤ I) | |
| {g h : Domain P → ℝ} (hgm : Measurable g) (hhm : Measurable h) | |
| (hg : ∀ z, |g z| ≤ S) (hh : ∀ z, |h z| ≤ S) (hgh : ∀ z, |g z-h z| ≤ D) | |
| (z : Domain P) : |value T L flow f₀ g z-value T L flow k₀ h z| ≤ I+T*D := by | |
| have hsource := value_difference hT hL hD hflow f₀ hgm hhm hg hh hgh z | |
| have hinitial : |value T L flow f₀ h z-value T L flow k₀ h z| ≤ I := by | |
| have heq : value T L flow f₀ h z-value T L flow k₀ h z = | |
| Real.exp (-L*time T z.1) * (f₀ (flow (-time T z.1) z.2)-k₀ (flow (-time T z.1) z.2)) := by | |
| unfold value | |
| ring | |
| rw [heq, abs_mul, abs_of_pos (Real.exp_pos _)] | |
| have he : Real.exp (-L*time T z.1) ≤ 1 := Real.exp_le_one_iff.mpr | |
| (mul_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr hL) (time_bounds hT z.1).1) | |
| exact (mul_le_mul he (hfk _) (abs_nonneg _) (by norm_num)).trans_eq (one_mul I) | |
| exact (abs_sub_le _ _ _).trans ((add_le_add hsource hinitial).trans_eq (add_comm _ _)) | |
| end BoltzmannNonuniqueness.PositiveIntegral | |
| end | |
| end | |
| section | |
| /-! # Finite sums of positive characteristic integrals -/ | |
| noncomputable section | |
| open MeasureTheory | |
| open scoped BigOperators | |
| namespace BoltzmannNonuniqueness.PositiveIntegral | |
| variable {P I : Type*} [MeasurableSpace P] | |
| theorem value_finsetSum {T L S : ℝ} (hT : 0 ≤ T) (hL : 0 ≤ L) | |
| {flow : ℝ → P → P} (hflow : Measurable (fun z : ℝ × P => flow z.1 z.2)) | |
| (s : Finset I) (f₀ : I → P → ℝ) (g : I → Domain P → ℝ) | |
| (hgm : ∀ i ∈ s, Measurable (g i)) (hg : ∀ i ∈ s, ∀ z, |g i z| ≤ S) | |
| (z : Domain P) : | |
| ∑ i ∈ s, value T L flow (f₀ i) (g i) z = | |
| value T L flow (fun p => ∑ i ∈ s, f₀ i p) (fun q => ∑ i ∈ s, g i q) z := by | |
| unfold value | |
| rw [Finset.sum_add_distrib, Finset.mul_sum] | |
| congr 1 | |
| rw [← intervalIntegral.integral_finsetSum | |
| (fun i hi => damped_integrable hT hL hflow (hgm i hi) (hg i hi) z)] | |
| apply intervalIntegral.integral_congr | |
| intro r _ | |
| exact (Finset.mul_sum s _ _).symm | |
| end BoltzmannNonuniqueness.PositiveIntegral | |
| end | |
| end | |
| section | |
| /-! # Countable positive sums in the characteristic equation -/ | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped Topology | |
| namespace BoltzmannNonuniqueness.PositiveIntegral | |
| variable {P I : Type*} [MeasurableSpace P] [Countable I] | |
| theorem hasSum_value {T L S : ℝ} (hT : 0 ≤ T) (hL : 0 ≤ L) | |
| {flow : ℝ → P → P} (hflow : Measurable (fun z : ℝ × P => flow z.1 z.2)) | |
| (f₀ : I → P → ℝ) (hf₀ : ∀ p, Summable (fun i => f₀ i p)) | |
| (g : I → Domain P → ℝ) (hgm : ∀ i, Measurable (g i)) | |
| (hg : ∀ i z, 0 ≤ g i z ∧ g i z ≤ S) | |
| (hgs : ∀ z, Summable (fun i => g i z)) (hgb : ∀ z, (∑' i, g i z) ≤ S) | |
| (z : Domain P) : HasSum (fun i => value T L flow (f₀ i) (g i) z) | |
| (value T L flow (fun p => ∑' i, f₀ i p) (fun q => ∑' i, g i q) z) := by | |
| have hsm : Measurable (fun q => ∑' i, g i q) := Measurable.tsum hgm | |
| have hsa (q) : |∑' i, g i q| ≤ S := by | |
| rw [abs_of_nonneg (tsum_nonneg (fun i => (hg i q).1))] | |
| exact hgb q | |
| have hgi (i) := damped_integrable hT hL hflow (hgm i) | |
| (fun q => by rw [abs_of_nonneg (hg i q).1]; exact (hg i q).2) z | |
| have hi := intervalIntegral.hasSum_integral_of_dominated_convergence | |
| (a := 0) (b := time T z.1) (μ := volume) | |
| (F := fun i r => Real.exp (-L * (time T z.1 - r)) * g i (r, flow (r - time T z.1) z.2)) | |
| (f := fun r => Real.exp (-L * (time T z.1 - r)) * | |
| ∑' i, g i (r, flow (r - time T z.1) z.2)) | |
| (fun i r => Real.exp (-L * (time T z.1 - r)) * g i (r, flow (r - time T z.1) z.2)) | |
| (fun i => (hgi i).def'.aestronglyMeasurable) | |
| (fun i => ae_of_all _ (fun r _ => by | |
| rw [Real.norm_eq_abs, abs_of_nonneg (mul_nonneg (Real.exp_pos _).le (hg i _).1)])) | |
| (ae_of_all _ (fun r _ => (hgs _).mul_left _)) | |
| (by | |
| simpa only [tsum_mul_left] using damped_integrable hT hL hflow hsm hsa z) | |
| (ae_of_all _ (fun r _ => (hgs _).hasSum.mul_left _)) | |
| exact ((hf₀ _).hasSum.mul_left (Real.exp (-L * time T z.1))).add hi | |
| end BoltzmannNonuniqueness.PositiveIntegral | |
| end | |
| end | |
| section | |
| /-! # Positive mass of an integral is bounded by the integral of positive mass -/ | |
| noncomputable section | |
| open MeasureTheory | |
| open scoped ENNReal | |
| namespace BoltzmannNonuniqueness | |
| variable {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y] | |
| theorem positive_marginal_bound {μ : Measure X} {ν : Measure Y} [SFinite μ] [SFinite ν] | |
| {f : X × Y → ℝ} (hfm : Measurable f) (hfi : Integrable f (μ.prod ν)) : | |
| (∫⁻ x, ENNReal.ofReal (∫ y, f (x,y) ∂ν) ∂μ) ≤ | |
| ∫⁻ z, ENNReal.ofReal (f z) ∂μ.prod ν := by | |
| rw [lintegral_prod _ hfm.ennreal_ofReal.aemeasurable] | |
| exact lintegral_mono_ae (hfi.prod_right_ae.mono (fun x hx => Published.ofReal_integral_le_lintegral hx)) | |
| end BoltzmannNonuniqueness | |
| end | |
| end | |
| end OAI | |